WIP

Author: rintaro

Sources/JExtractSwift/Swift2JavaTranslator+JavaBindingsPrinting.swift

@@ -522,10 +522,12 @@ extension Swift2JavaTranslator {
         "arena$"
       }
 
+      let varName = "_result" + outParameter.name
+
       printer.print(
-        "MemorySegment \(outParameter.name) = \(arena).allocate(\(memoryLayout));"
+        "MemorySegment \(varName) = \(arena).allocate(\(memoryLayout));"
       )
-      downCallArguments.append(outParameter.name)
+      downCallArguments.append(varName)
     }
 
     //=== Part 3: Downcall.
@@ -542,14 +544,14 @@ extension Swift2JavaTranslator {
     if isConstructor {
       // For constructors, the caller expects the "self" memory segment.
       printer.print("\(downCall);")
-      let outParameterName = decl.translatedSignature.result.outParameters[0].name
-      printer.print("return \(outParameterName);")
+      printer.print("return _result;")
     } else if decl.translatedSignature.result.javaResultType == .void {
       printer.print("\(downCall);")
     } else {
       let placeholder = if decl.translatedSignature.result.outParameters.isEmpty {
         downCall
       } else {
+        // FIXME: Support cdecl thunk returning a value while populating the out parameters.
         "_result"
       }
       let result = decl.translatedSignature.result.conversion.render(&printer, placeholder)
@@ -634,6 +636,8 @@ extension JavaConversionStep {
 
   /// Returns the conversion string applied to the placeholder.
   func render(_ printer: inout CodePrinter, _ placeholder: String) -> String {
+    // 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:
       return placeholder

Sources/JExtractSwift/Swift2JavaTranslator+JavaTranslation.swift

@@ -38,42 +38,48 @@ struct JavaParameter {
   var name: String
 }
 
-enum JavaModifier {
-  // Access modifiers
-  case `public`
-  case `private`
-  case `protected`
-
-  // Non-access modifiers.
-  case `final`
-  case `static`
-  case `abstract`
-  case `transient`
-  case `synchronized`
-  case `volatile`
-}
-
-struct JavaMethodSignature {
-  var modifiers: [JavaModifier]
-  var returnType: JavaType
-  var parameters: [JavaParameter]
-}
-
+/// Represent a Swift API parameter translated to Java.
 struct TranslatedParameter {
+  /// Java parameter(s) mapped to the Swift parameter.
+  ///
+  /// Array because one Swift parameter can be mapped to multiple parameters.
   var javaParameters: [JavaParameter]
+
+  /// Describes how to convert the Java parameter to the lowered arguments for
+  /// the foreign function.
   var conversion: JavaConversionStep
 }
 
+/// Represent a Swift API result translated to Java.
 struct TranslatedResult {
+  /// Java type that represents the Swift result type.
   var javaResultType: JavaType
+
+  /// Required indirect return receivers for receiving the result.
+  ///
+  /// 'JavaParameter.name' is the suffix for the receiver variable names. For example
+  ///
+  ///   var _result_pointer = MemorySegment.allocate(...)
+  ///   var _result_count = MemroySegment.allocate(...)
+  ///   downCall(_result_pointer, _result_count)
+  ///   return constructResult(_result_pointer, _result_count)
+  ///
+  /// This case, there're two out parameter, named '_pointer' and '_count'.
   var outParameters: [JavaParameter]
+
+  /// Describes how to construct the Java result from the foreign function return
+  /// value and/or the out parameters.
   var conversion: JavaConversionStep
 }
 
+/// Translated function signature representing a Swift API.
+///
+/// Since this holds the lowered signature, and the original `SwiftFunctionSignature`
+/// in it, this contains all the API information (except the name) to generate the
+/// cdecl thunk, Java binding, and the Java wrapper function.
 struct TranslatedFunctionSignature {
   var loweredSignature: LoweredFunctionSignature
 
-  ///
   var selfParameter: TranslatedParameter?
   var parameters: [TranslatedParameter]
   var result: TranslatedResult
@@ -304,7 +310,7 @@ struct JavaTranslation {
       return TranslatedResult(
         javaResultType: javaType,
         outParameters: [
-          JavaParameter(type: javaType, name: "_result")
+          JavaParameter(type: javaType, name: "")
         ],
         conversion: .constructSwiftValue(javaType)
       )
@@ -341,7 +347,7 @@ enum JavaConversionStep {
   // If `withArena` is true, `arena$` argument is added.
   case call(function: String, withArena: Bool)
 
-  // Call '\(Type)(\(placeholder), arena$)'.
+  // Call 'new \(Type)(\(placeholder), swiftArena$)'.
   case constructSwiftValue(JavaType)
 
   // Construct the type using the placeholder as arguments.