[JExtract/FFM] Lowering Optional parameters

Author: rintaro

Sources/JExtractSwiftLib/FFM/CDeclLowering/CRepresentation.swift

@@ -125,7 +125,7 @@ extension SwiftKnownTypeDeclKind {
       .qualified(const: true, volatile: false, type: .void)
     )
     case .void: .void
-    case .unsafePointer, .unsafeMutablePointer, .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer, .unsafeBufferPointer, .unsafeMutableBufferPointer, .string, .data, .dataProtocol:
+    case .unsafePointer, .unsafeMutablePointer, .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer, .unsafeBufferPointer, .unsafeMutableBufferPointer, .string, .data, .dataProtocol, .optional:
        nil
     }
   }

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

@@ -253,6 +253,12 @@ struct CdeclLowering {
               ]
             ))
 
+        case .optional:
+          guard let genericArgs = type.asNominalType?.genericArguments, genericArgs.count == 1 else {
+            throw LoweringError.unhandledType(type)
+          }
+          return try lowerOptionalParameter(genericArgs[0], convention: convention, parameterName: parameterName)
+
         case .string:
           // 'String' is passed in by C string. i.e. 'UnsafePointer<Int8>' ('const uint8_t *')
           if knownType == .string {
@@ -336,8 +342,79 @@ struct CdeclLowering {
       }
       throw LoweringError.unhandledType(type)
 
-    case .optional:
-      throw LoweringError.unhandledType(type)
+    case .optional(let wrapped):
+      return try lowerOptionalParameter(wrapped, convention: convention, parameterName: parameterName)
+    }
+  }
+
+  /// Lower a Swift Optional to cdecl function type.
+  ///
+  /// - Parameters:
+  ///   - fn: the Swift function type to lower.
+  func lowerOptionalParameter(
+    _ wrappedType: SwiftType,
+    convention: SwiftParameterConvention,
+    parameterName: String
+  ) throws -> LoweredParameter {
+    // If there is a 1:1 mapping between this Swift type and a C type, lower it to 'UnsafePointer<T>?'
+    if let _ = try? CType(cdeclType: wrappedType) {
+      return LoweredParameter(
+        cdeclParameters: [
+          SwiftParameter(convention: .byValue, parameterName: parameterName, type: .optional(knownTypes.unsafePointer(wrappedType)))
+        ],
+        conversion: .pointee(.optionalChain(.placeholder))
+      )
+    }
+
+    switch wrappedType {
+    case .nominal(let nominal):
+      if let knownType = nominal.nominalTypeDecl.knownTypeKind {
+        switch knownType {
+        case .data:
+          break
+        case .unsafeRawPointer, .unsafeMutableRawPointer:
+          throw LoweringError.unhandledType(.optional(wrappedType))
+        case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
+          throw LoweringError.unhandledType(.optional(wrappedType))
+        case .unsafePointer, .unsafeMutablePointer:
+          throw LoweringError.unhandledType(.optional(wrappedType))
+        case .unsafeBufferPointer, .unsafeMutableBufferPointer:
+          throw LoweringError.unhandledType(.optional(wrappedType))
+        case .void, .string:
+          throw LoweringError.unhandledType(.optional(wrappedType))
+        case .dataProtocol:
+          throw LoweringError.unhandledType(.optional(wrappedType))
+        default:
+          // Unreachable? Should be handled by `CType(cdeclType:)` lowering above.
+          throw LoweringError.unhandledType(.optional(wrappedType))
+        }
+      }
+
+      // Lower arbitrary nominal to `UnsafeRawPointer?`
+      return LoweredParameter(
+        cdeclParameters: [
+          SwiftParameter(convention: .byValue, parameterName: parameterName, type: .optional(knownTypes.unsafeRawPointer))
+        ],
+        conversion: .pointee(.typedPointer(.optionalChain(.placeholder), swiftType: wrappedType))
+      )
+
+    case .existential(let proto), .opaque(let proto):
+      if
+        let knownProtocol = proto.asNominalTypeDeclaration?.knownTypeKind,
+        let concreteTy = knownTypes.representativeType(of: knownProtocol)
+      {
+        return try lowerOptionalParameter(concreteTy, convention: convention, parameterName: parameterName)
+      }
+      throw LoweringError.unhandledType(.optional(wrappedType))
+      
+    case .tuple(let tuple):
+      if tuple.count == 1 {
+        return try lowerOptionalParameter(tuple[0], convention: convention, parameterName: parameterName)
+      }
+      throw LoweringError.unhandledType(.optional(wrappedType))
+
+    case .function, .metatype, .optional:
+      throw LoweringError.unhandledType(.optional(wrappedType))
     }
   }
 
@@ -527,13 +604,13 @@ struct CdeclLowering {
         case .void:
           return LoweredResult(cdeclResultType: .void, cdeclOutParameters: [], conversion: .placeholder)
 
-        case .string:
-          // Returning string is not supported at this point.
-          throw LoweringError.unhandledType(type)
-
         case .data:
           break
 
+        case .string, .optional:
+          // Not supported at this point.
+          throw LoweringError.unhandledType(type)
+
         default:
           // Unreachable? Should be handled by `CType(cdeclType:)` lowering above.
           throw LoweringError.unhandledType(type)

Sources/JExtractSwiftLib/FFM/ConversionStep.swift

@@ -62,6 +62,8 @@ enum ConversionStep: Equatable {
 
   indirect case member(ConversionStep, member: String)
 
+  indirect case optionalChain(ConversionStep)
+
   /// Count the number of times that the placeholder occurs within this
   /// conversion step.
   var placeholderCount: Int {
@@ -71,7 +73,7 @@ enum ConversionStep: Equatable {
         .typedPointer(let inner, swiftType: _),
         .unsafeCastPointer(let inner, swiftType: _),
         .populatePointer(name: _, assumingType: _, to: let inner),
-        .member(let inner, member: _):
+        .member(let inner, member: _), .optionalChain(let inner):
       inner.placeholderCount
     case .initialize(_, arguments: let arguments):
       arguments.reduce(0) { $0 + $1.argument.placeholderCount }
@@ -175,6 +177,10 @@ enum ConversionStep: Equatable {
       }
       return nil
 
+    case .optionalChain(let step):
+      let inner = step.asExprSyntax(placeholder: placeholder, bodyItems: &bodyItems)
+      return ExprSyntax(OptionalChainingExprSyntax(expression: inner!))
+
     case .closureLowering(let parameterSteps, let resultStep):
       var body: [CodeBlockItemSyntax] = []
 

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -99,7 +99,7 @@ extension JNISwift2JavaGenerator {
           .unsafeRawPointer, .unsafeMutableRawPointer,
           .unsafePointer, .unsafeMutablePointer,
           .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer,
-          .unsafeBufferPointer, .unsafeMutableBufferPointer, .data, .dataProtocol:
+          .unsafeBufferPointer, .unsafeMutableBufferPointer, .optional, .data, .dataProtocol:
         nil
       }
     }

Sources/JExtractSwiftLib/SwiftTypes/SwiftKnownModules.swift

@@ -76,6 +76,8 @@ private let swiftSourceFile: SourceFileSyntax = """
   public struct UnsafeBufferPointer<Element> {}
   public struct UnsafeMutableBufferPointer<Element> {}
   
+  public struct Optional<Wrapped> {}
+  
   // FIXME: Support 'typealias Void = ()'
   public struct Void {}
   

Sources/JExtractSwiftLib/SwiftTypes/SwiftKnownTypeDecls.swift

@@ -36,6 +36,7 @@ enum SwiftKnownTypeDeclKind: String, Hashable {
   case unsafeMutablePointer = "Swift.UnsafeMutablePointer"
   case unsafeBufferPointer = "Swift.UnsafeBufferPointer"
   case unsafeMutableBufferPointer = "Swift.UnsafeMutableBufferPointer"
+  case optional = "Swift.Optional"
   case void = "Swift.Void"
   case string = "Swift.String"
 

Tests/JExtractSwiftTests/FunctionLoweringTests.swift

@@ -383,6 +383,27 @@ final class FunctionLoweringTests {
     )
   }
 
+  @Test("Lowering optional primitives")
+  func lowerOptionalParameters() throws {
+    try assertLoweredFunction(
+      """
+      func fn(a1: Optional<Int>, a2: Int?, a3: Point?, a4: (some DataProtocol)?)  
+      """,
+      sourceFile: """
+      import Foundation
+      struct Point {}
+      """,
+      expectedCDecl:"""
+      @_cdecl("c_fn")
+      public func c_fn(_ a1: UnsafePointer<Int>?, _ a2: UnsafePointer<Int>?, _ a3: UnsafeRawPointer?, _ a4: UnsafeRawPointer?) {
+        fn(a1: a1?.pointee, a2: a2?.pointee, a3: a3?.assumingMemoryBound(to: Point.self).pointee, a4: a4?.assumingMemoryBound(to: Data.self).pointee)
+      }
+      """,
+      expectedCFunction: """
+      void c_fn(const ptrdiff_t *a1, const ptrdiff_t *a2, const void *a3, const void *a4)
+      """)
+  }
+
   @Test("Lowering read accessor")
   func lowerGlobalReadAccessor() throws {
     try assertLoweredVariableAccessor(