[JExtract] Bridge UnsafeRawBufferPointer

Lower `Unsafe(Mutable)RawBufferPointer` to a pair of pointer and count.
Implement parameter and result conversion both in Swift thunks and Java
bindings.

`JavaConversionStep` is now nested structure just like `ConversionStep`.

Author: rintaro

Samples/SwiftKitSampleApp/Sources/MySwiftLibrary/MySwiftLibrary.swift

@@ -47,6 +47,12 @@ public func globalCallMeRunnable(run: () -> ()) {
   run()
 }
 
+public func globalReceiveRawBuffer(buf: UnsafeRawBufferPointer) -> Int {
+  return buf.count
+}
+
+public var globalBuffer: UnsafeRawBufferPointer = UnsafeRawBufferPointer(UnsafeMutableRawBufferPointer.allocate(byteCount: 124, alignment: 1))
+
 // ==== Internal helpers
 
 func p(_ msg: String, file: String = #fileID, line: UInt = #line, function: String = #function) {

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

@@ -45,6 +45,8 @@ static void examples() {
             SwiftKit.trace("running runnable");
         });
 
+        SwiftKit.trace("getGlobalBuffer().byteSize()=" + MySwiftLibrary.getGlobalBuffer().byteSize());
+
         // Example of using an arena; MyClass.deinit is run at end of scope
         try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass obj = MySwiftClass.init(2222, 7777, arena);

Sources/ExampleSwiftLibrary/MySwiftLibrary.swift

@@ -41,6 +41,10 @@ public func globalCallMeRunnable(run: () -> ()) {
   run()
 }
 
+public func globalReceiveRawBuffer(buf: UnsafeRawBufferPointer) -> Int {
+  return buf.count
+}
+
 public class MySwiftClass {
 
   public var len: Int

Sources/JExtractSwiftLib/FFM/CDeclLowering/CRepresentation.swift

@@ -65,6 +65,9 @@ extension CType {
     case .tuple([]):
       self = .void
 
+    case .optional(let wrapped) where wrapped.isPointer:
+      try self.init(cdeclType: wrapped)
+
     case .metatype, .optional, .tuple:
       throw CDeclToCLoweringError.invalidCDeclType(cdeclType)
     }
@@ -122,7 +125,7 @@ extension SwiftStandardLibraryTypeKind {
       .qualified(const: true, volatile: false, type: .void)
     )
     case .void: .void
-    case .unsafePointer, .unsafeMutablePointer, .unsafeBufferPointer, .unsafeMutableBufferPointer, .string:
+    case .unsafePointer, .unsafeMutablePointer, .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer, .unsafeBufferPointer, .unsafeMutableBufferPointer, .string:
        nil
     }
   }

Sources/JExtractSwiftLib/FFM/CDeclLowering/FFMSwift2JavaGenerator+FunctionLowering.swift

@@ -215,6 +215,35 @@ struct CdeclLowering {
             )
           )
 
+        case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
+          // pointer buffers are lowered to (raw-pointer, count) pair.
+          let isMutable = knownType == .unsafeMutableRawBufferPointer
+          return LoweredParameter(
+            cdeclParameters: [
+              SwiftParameter(
+                convention: .byValue,
+                parameterName: "\(parameterName)_pointer",
+                type: .optional(isMutable ? knownTypes.unsafeMutableRawPointer : knownTypes.unsafeRawPointer)
+              ),
+              SwiftParameter(
+                convention: .byValue, parameterName: "\(parameterName)_count",
+                type: knownTypes.int
+              )
+            ],
+            conversion: .initialize(
+              type,
+              arguments: [
+                LabeledArgument(
+                  label: "start",
+                  argument: .explodedComponent(.placeholder, component: "pointer")
+                ),
+                LabeledArgument(
+                  label: "count",
+                  argument: .explodedComponent(.placeholder, component: "count")
+                )
+              ]
+            ))
+
         case .string:
           // 'String' is passed in by C string. i.e. 'UnsafePointer<Int8>' ('const uint8_t *')
           if knownType == .string {
@@ -377,6 +406,37 @@ struct CdeclLowering {
             outParameterName: outParameterName
           )
 
+        case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
+          // pointer buffers are lowered to (raw-pointer, count) pair.
+          let isMutable = knownType == .unsafeMutableRawBufferPointer
+          return LoweredResult(
+            cdeclResultType: .void,
+            cdeclOutParameters: [
+              SwiftParameter(
+                convention: .byValue,
+                parameterName: "\(outParameterName)_pointer",
+                type: knownTypes.unsafeMutablePointer(
+                  .optional(isMutable ? knownTypes.unsafeMutableRawPointer : knownTypes.unsafeRawPointer)
+                )
+              ),
+              SwiftParameter(
+                convention: .byValue,
+                parameterName: "\(outParameterName)_count",
+                type: knownTypes.unsafeMutablePointer(knownTypes.int)
+              ),
+            ],
+            conversion: .aggregate([
+              .populatePointer(
+                name: "\(outParameterName)_pointer",
+                to: .member(.placeholder, member: "baseAddress")
+              ),
+              .populatePointer(
+                name: "\(outParameterName)_count",
+                to: .member(.placeholder, member: "count")
+              )
+            ], name: outParameterName)
+          )
+
         case .void:
           return LoweredResult(cdeclResultType: .void, cdeclOutParameters: [], conversion: .placeholder)
 

Sources/JExtractSwiftLib/FFM/ConversionStep.swift

@@ -52,9 +52,14 @@ enum ConversionStep: Equatable {
   /// Initialize mutable raw pointer with a typed value.
   indirect case populatePointer(name: String, assumingType: SwiftType? = nil, to: ConversionStep)
 
-  /// Perform multiple conversions, but discard the result.
+  /// Perform multiple conversions for each tuple input elements, but discard the result.
   case tupleExplode([ConversionStep], name: String?)
 
+  /// Perform multiple conversions using the same input.
+  case aggregate([ConversionStep], name: String?)
+
+  indirect case member(ConversionStep, member: String)
+
   /// Count the number of times that the placeholder occurs within this
   /// conversion step.
   var placeholderCount: Int {
@@ -63,13 +68,14 @@ enum ConversionStep: Equatable {
         .pointee(let inner),
         .typedPointer(let inner, swiftType: _),
         .unsafeCastPointer(let inner, swiftType: _),
-        .populatePointer(name: _, assumingType: _, to: let inner):
+        .populatePointer(name: _, assumingType: _, to: let inner),
+        .member(let inner, member: _):
       inner.placeholderCount
     case .initialize(_, arguments: let arguments):
       arguments.reduce(0) { $0 + $1.argument.placeholderCount }
     case .placeholder, .tupleExplode:
       1
-    case .tuplify(let elements):
+    case .tuplify(let elements), .aggregate(let elements, _):
       elements.reduce(0) { $0 + $1.placeholderCount }
     }
   }
@@ -140,6 +146,25 @@ enum ConversionStep: Equatable {
         }
       }
       return nil
+
+    case .member(let step, let member):
+      let inner = step.asExprSyntax(placeholder: placeholder, bodyItems: &bodyItems)
+      return "\(inner).\(raw: member)"
+
+    case .aggregate(let steps, let name):
+      let toExplode: String
+      if let name {
+        bodyItems.append("let \(raw: name) = \(raw: placeholder)")
+        toExplode = name
+      } else {
+        toExplode = placeholder
+      }
+      for step in steps {
+        if let result = step.asExprSyntax(placeholder: toExplode, bodyItems: &bodyItems) {
+          bodyItems.append(CodeBlockItemSyntax(item: .expr(result)))
+        }
+      }
+      return nil
     }
   }
 }

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -365,7 +365,7 @@ extension FFMSwift2JavaGenerator {
         "arena$"
       }
 
-      let varName = "_result" + outParameter.name
+      let varName = outParameter.name.isEmpty ? "_result" : "_result_" + outParameter.name
 
       printer.print(
         "MemorySegment \(varName) = \(arena).allocate(\(memoryLayout));"
@@ -419,32 +419,35 @@ extension JavaConversionStep {
   /// Whether the conversion uses SwiftArena.
   var requiresSwiftArena: Bool {
     switch self {
-    case .pass, .swiftValueSelfSegment, .construct, .cast, .call, .method:
+    case .placeholder, .constant, .readOutParameter:
       return false
     case .constructSwiftValue:
       return true
+
+    case .call(let inner, _, _), .cast(let inner, _), .construct(let inner, _),
+        .method(let inner, _, _, _), .swiftValueSelfSegment(let inner):
+      return inner.requiresSwiftArena
+
+    case .commaSeparated(let list):
+      return list.contains(where: { $0.requiresSwiftArena })
     }
   }
 
   /// Whether the conversion uses temporary Arena.
   var requiresTemporaryArena: Bool {
     switch self {
-    case .pass, .swiftValueSelfSegment, .construct, .constructSwiftValue, .cast:
+    case .placeholder, .constant:
       return false
-    case .call(_, let withArena), .method(_, _, let withArena):
-      return withArena
-    }
-  }
-
-  /// Whether if the result evaluation is trivial.
-  ///
-  /// If this is false, it's advised to store it to a variable if it's used multiple times
-  var isTrivial: Bool {
-    switch self {
-    case .pass, .swiftValueSelfSegment:
+    case .readOutParameter:
       return true
-    case .cast, .construct, .constructSwiftValue, .call, .method:
-      return false
+    case .cast(let inner, _), .construct(let inner, _), .constructSwiftValue(let inner, _), .swiftValueSelfSegment(let inner):
+      return inner.requiresSwiftArena
+    case .call(let inner, _, let withArena):
+      return withArena || inner.requiresTemporaryArena
+    case .method(let inner, _, let args, let withArena):
+      return withArena || inner.requiresTemporaryArena || args.contains(where: { $0.requiresTemporaryArena })
+    case .commaSeparated(let list):
+      return list.contains(where: { $0.requiresTemporaryArena })
     }
   }
 
@@ -453,28 +456,43 @@ extension JavaConversionStep {
     // NOTE: 'printer' is used if the conversion wants to cause side-effects.
     // E.g. storing a temporary values into a variable.
     switch self {
-    case .pass:
+    case .placeholder:
       return placeholder
 
     case .swiftValueSelfSegment:
       return "\(placeholder).$memorySegment()"
 
-    case .call(let function, let withArena):
+    case .call(let inner, let function, let withArena):
+      let inner = inner.render(&printer, placeholder)
       let arenaArg = withArena ? ", arena$" : ""
-      return "\(function)(\(placeholder)\(arenaArg))"
+      return "\(function)(\(inner)\(arenaArg))"
+
+    case .method(let inner, let methodName, let arguments, let withArena):
+      let inner = inner.render(&printer, placeholder)
+      let args = arguments.map { $0.render(&printer, placeholder) }
+      let argsStr = (args + (withArena ? ["arena$"] : [])).joined(separator: " ,")
+      return "\(inner).\(methodName)(\(argsStr))"
+
+    case .constructSwiftValue(let inner, let javaType):
+      let inner = inner.render(&printer, placeholder)
+      return "new \(javaType.className!)(\(inner), swiftArena$)"
+
+    case .construct(let inner, let javaType):
+      let inner = inner.render(&printer, placeholder)
+      return "new \(javaType)(\(inner))"
 
-    case .method(let methodName, let arguments, let withArena):
-      let argsStr = (arguments + (withArena ? ["arena$"] : [])).joined(separator: " ,")
-      return "\(placeholder).\(methodName)(\(argsStr))"
+    case .cast(let inner, let javaType):
+      let inner = inner.render(&printer, placeholder)
+      return "(\(javaType)) \(inner)"
 
-    case .constructSwiftValue(let javaType):
-      return "new \(javaType.className!)(\(placeholder), swiftArena$)"
+    case .commaSeparated(let list):
+      return list.map({ $0.render(&printer, placeholder)}).joined(separator: ", ")
 
-    case .construct(let javaType):
-      return "new \(javaType)(\(placeholder))"
+    case .constant(let value):
+      return value
 
-    case .cast(let javaType):
-      return "(\(javaType)) \(placeholder)"
+    case .readOutParameter(let javaType, let name):
+      return "\(placeholder)_\(name).get(\(ForeignValueLayout(javaType: javaType)!), 0)"
     }
   }
 }