cdecl thunks: property initialize indirect returns via initialize(to:)

This requires us to walk the parallel structure between indirect
returns (where we need to introduce the initialize(to:) calls instead
of pointee references) and the Swift value.

Author: DougGregor

Sources/JExtractSwift/CDeclLowering/Swift2JavaTranslator+FunctionLowering.swift

@@ -430,17 +430,6 @@ extension LoweredFunctionSignature {
         originalResult = callExpression
       }
 
-      // FIXME: Check whether there are multiple places in which we reference
-      // the placeholder in resultConversion. If so, we should write it into a
-      // local let "_resultValue" or similar so we don't call the underlying
-      // function multiple times.
-
-      // Convert the result.
-      let convertedResult = resultConversion.asExprSyntax(
-        isSelf: true,
-        placeholder: originalResult.description
-      )
-
       if cdecl.result.type.isVoid {
         // Indirect return. This is a regular return in Swift that turns
         // into an assignment via the indirect parameters. We do a cdeclToSwift
@@ -450,16 +439,23 @@ extension LoweredFunctionSignature {
         let cdeclParamConversion = try! ConversionStep(
           cdeclToSwift: original.result.type
         )
-        let indirectResults = cdeclParamConversion.asExprSyntax(
-          isSelf: true,
-          placeholder: "_result"
-        )
-        bodyItems.append("""
-            \(indirectResults) = \(convertedResult)
-          """
+
+        // For each indirect result, initialize the value directly with the
+        // corresponding element in the converted result.
+        bodyItems.append(
+          contentsOf: cdeclParamConversion.initialize(
+            placeholder: "_result",
+            from: resultConversion,
+            otherPlaceholder: originalResult.description
+          )
         )
       } else {
         // Direct return. Just convert the expression.
+        let convertedResult = resultConversion.asExprSyntax(
+          isSelf: true,
+          placeholder: originalResult.description
+        )
+
         bodyItems.append("""
             return \(convertedResult)
           """
@@ -475,3 +471,58 @@ extension LoweredFunctionSignature {
     return loweredCDecl
   }
 }
+
+extension ConversionStep {
+  /// Form a set of statements that initializes the placeholders within
+  /// the given conversion step from ones in the other step, effectively
+  /// exploding something like `(a, (b, c)) = (d, (e, f))` into
+  /// separate initializations for a, b, and c from d, e, and f, respectively.
+  func initialize(
+    placeholder: String,
+    from otherStep: ConversionStep,
+    otherPlaceholder: String
+  ) -> [CodeBlockItemSyntax] {
+    // Create separate assignments for each element in paired tuples.
+    if case .tuplify(let elements) = self,
+        case .tuplify(let otherElements) = otherStep {
+      assert(elements.count == otherElements.count)
+
+      return elements.indices.flatMap { index in
+        elements[index].initialize(
+          placeholder: "\(placeholder)_\(index)",
+          from: otherElements[index],
+          otherPlaceholder: "\(otherPlaceholder)_\(index)"
+        )
+      }
+    }
+
+    // Look through "pass indirectly" steps; they do nothing here.
+    if case .passIndirectly(let conversionStep) = self {
+      return conversionStep.initialize(
+        placeholder: placeholder,
+        from: otherStep,
+        otherPlaceholder: otherPlaceholder
+      )
+    }
+
+    // The value we're initializing from.
+    let otherExpr = otherStep.asExprSyntax(
+      isSelf: false,
+      placeholder: otherPlaceholder
+    )
+
+    // If we have a "pointee" on where we are performing initialization, we
+    // need to instead produce an initialize(to:) call.
+    if case .pointee(let innerSelf) = self {
+      let selfPointerExpr = innerSelf.asExprSyntax(
+        isSelf: true,
+        placeholder: placeholder
+      )
+
+      return [ "  \(selfPointerExpr).initialize(to: \(otherExpr))" ]
+    }
+
+    let selfExpr = self.asExprSyntax(isSelf: true, placeholder: placeholder)
+    return [ "  \(selfExpr) = \(otherExpr)" ]
+  }
+}

Tests/JExtractSwiftTests/FunctionLoweringTests.swift

@@ -79,7 +79,7 @@ final class FunctionLoweringTests {
       expectedCDecl: """
       @_cdecl("c_shifted")
       func c_shifted(_ delta_0: Double, _ delta_1: Double, _ self: UnsafeRawPointer, _ _result: UnsafeMutableRawPointer) {
-        _result.assumingMemoryBound(to: Point.self).pointee = self.assumingMemoryBound(to: Point.self).pointee.shifted(by: (delta_0, delta_1))
+        _result.assumingMemoryBound(to: Point.self).initialize(to: self.assumingMemoryBound(to: Point.self).pointee.shifted(by: (delta_0, delta_1)))
       }
       """,
       expectedCFunction: "void c_shifted(double delta_0, double delta_1, void const* self, void* _result)"
@@ -136,7 +136,7 @@ final class FunctionLoweringTests {
       expectedCDecl: """
       @_cdecl("c_scaledUnit")
       func c_scaledUnit(_ value: Double, _ _result: UnsafeMutableRawPointer) {
-        _result.assumingMemoryBound(to: Point.self).pointee = Point.scaledUnit(by: value)
+        _result.assumingMemoryBound(to: Point.self).initialize(to: Point.scaledUnit(by: value))
       }
       """,
       expectedCFunction: "void c_scaledUnit(double value, void* _result)"
@@ -171,7 +171,7 @@ final class FunctionLoweringTests {
       expectedCDecl: """
       @_cdecl("c_init")
       func c_init(_ value: Double, _ _result: UnsafeMutableRawPointer) {
-        _result.assumingMemoryBound(to: Point.self).pointee = Point(scaledBy: value)
+        _result.assumingMemoryBound(to: Point.self).initialize(to: Point(scaledBy: value))
       }
       """,
       expectedCFunction: "void c_init(double value, void* _result)"
@@ -261,13 +261,18 @@ final class FunctionLoweringTests {
   @Test("Lowering tuple returns")
   func lowerTupleReturns() throws {
     try assertLoweredFunction("""
-      func getTuple() -> (Int, (Float, Double)) { }
+      func getTuple() -> (Int, (Float, Point)) { }
+      """,
+      sourceFile: """
+      struct Point { }
       """,
       expectedCDecl: """
       @_cdecl("c_getTuple")
       func c_getTuple(_ _result_0: UnsafeMutableRawPointer, _ _result_1_0: UnsafeMutableRawPointer, _ _result_1_1: UnsafeMutableRawPointer) {
         let __swift_result = getTuple()
-        (_result_0, (_result_1_0, _result_1_1)) = (__swift_result_0, (__swift_result_1_0, __swift_result_1_1))
+        _result_0 = __swift_result_0
+        _result_1_0 = __swift_result_1_0
+        _result_1_1.assumingMemoryBound(to: Point.self).initialize(to: __swift_result_1_1)
       }
       """,
       expectedCFunction: "void c_getTuple(void* _result_0, void* _result_1_0, void* _result_1_1)"