Separate Swift-to-cdecl parameter lowering from the conversion sequences

Make the operation to convert from cdecl parameter(s) into a Swift parameter
a standalone operation, separate from the lowering of Swift parameters to
cdecl parameters. They need to be synchronized, but they are not the same.

Author: DougGregor

Sources/JExtractSwift/CDeclLowering/CDeclConversions.swift

@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+extension ConversionStep {
+  /// Produce a conversion that takes in a value (or set of values) that
+  /// would be available in a @_cdecl function to represent the given Swift
+  /// type, and convert that to an instance of the Swift type.
+  init(cdeclToSwift swiftType: SwiftType) throws {
+    switch swiftType {
+    case .function, .optional:
+      throw LoweringError.unhandledType(swiftType)
+
+    case .metatype(let instanceType):
+      self = .unsafeCastPointer(
+        .placeholder,
+        swiftType: instanceType
+      )
+
+    case .nominal(let nominal):
+      if let knownType = nominal.nominalTypeDecl.knownStandardLibraryType {
+        // Swift types that map to primitive types in C. These can be passed
+        // through directly.
+        if knownType.primitiveCType != nil {
+          self = .placeholder
+          return
+        }
+
+        // Typed pointers
+        if let firstGenericArgument = nominal.genericArguments?.first {
+          switch knownType {
+          case .unsafePointer, .unsafeMutablePointer:
+            self = .typedPointer(
+              .explodedComponent(.placeholder, component: "pointer"),
+              swiftType: firstGenericArgument
+            )
+            return
+
+          case .unsafeBufferPointer, .unsafeMutableBufferPointer:
+            self = .initialize(
+              swiftType,
+              arguments: [
+                LabeledArgument(
+                  label: "start",
+                  argument: .typedPointer(
+                    .explodedComponent(.placeholder, component: "pointer"),
+                    swiftType: firstGenericArgument)
+                ),
+                LabeledArgument(
+                  label: "count",
+                  argument: .explodedComponent(.placeholder, component: "count")
+                )
+              ]
+            )
+            return
+
+          default:
+            break
+          }
+        }
+      }
+
+      // Arbitrary nominal types.
+      switch nominal.nominalTypeDecl.kind {
+      case .actor, .class:
+        // For actor and class, we pass around the pointer directly.
+        self = .unsafeCastPointer(.placeholder, swiftType: swiftType)
+      case .enum, .struct, .protocol:
+        // For enums, structs, and protocol types, we pass around the
+        // values indirectly.
+        self = .passIndirectly(
+          .pointee(.typedPointer(.placeholder, swiftType: swiftType))
+        )
+      }
+
+    case .tuple(let elements):
+      self = .tuplify(try elements.map { try ConversionStep(cdeclToSwift: $0) })
+    }
+  }
+}

Sources/JExtractSwift/SwiftTypes/SwiftStandardLibraryTypes+CLowering.swift renamed to Sources/JExtractSwift/CDeclLowering/CRepresentation.swift

@@ -12,17 +12,19 @@
 //
 //===----------------------------------------------------------------------===//
 
-extension SwiftStandardLibraryTypes {
+extension CType {
   /// Lower the given Swift type down to a its corresponding C type.
   ///
   /// This operation only supports the subset of Swift types that are
   /// representable in a Swift `@_cdecl` function. If lowering an arbitrary
   /// Swift function, first go through Swift -> cdecl lowering.
-  func cdeclToCLowering(_ swiftType: SwiftType) throws -> CType {
-    switch swiftType {
+  init(cdeclType: SwiftType) throws {
+    switch cdeclType {
     case .nominal(let nominalType):
-      if let knownType = self[nominalType.nominalTypeDecl] {
-        return try knownType.loweredCType()
+      if let knownType = nominalType.nominalTypeDecl.knownStandardLibraryType,
+        let primitiveCType = knownType.primitiveCType {
+        self = primitiveCType
+        return
       }
 
       throw CDeclToCLoweringError.invalidNominalType(nominalType.nominalTypeDecl)
@@ -33,29 +35,59 @@ extension SwiftStandardLibraryTypes {
         throw CDeclToCLoweringError.invalidFunctionConvention(functionType)
 
       case .c:
-        let resultType = try cdeclToCLowering(functionType.resultType)
+        let resultType = try CType(cdeclType: functionType.resultType)
         let parameterTypes = try functionType.parameters.map { param in
-          try cdeclToCLowering(param.type)
+          try CType(cdeclType: param.type)
         }
 
-        return .function(
+        self = .function(
           resultType: resultType,
           parameters: parameterTypes,
           variadic: false
         )
       }
 
     case .tuple([]):
-      return .void
+      self = .void
 
     case .metatype, .optional, .tuple:
-      throw CDeclToCLoweringError.invalidCDeclType(swiftType)
+      throw CDeclToCLoweringError.invalidCDeclType(cdeclType)
     }
   }
 }
 
+extension CFunction {
+  /// Produce a C function that represents the given @_cdecl Swift function.
+  init(cdeclSignature: SwiftFunctionSignature, cName: String) throws {
+    assert(cdeclSignature.selfParameter == nil)
+
+    let cResultType = try CType(cdeclType: cdeclSignature.result.type)
+    let cParameters = try cdeclSignature.parameters.map { parameter in
+      CParameter(
+        name: parameter.parameterName,
+        type: try CType(cdeclType: parameter.type).parameterDecay
+      )
+    }
+
+    self = CFunction(
+      resultType: cResultType,
+      name: cName,
+      parameters: cParameters,
+      isVariadic: false
+    )
+  }
+}
+
+enum CDeclToCLoweringError: Error {
+  case invalidCDeclType(SwiftType)
+  case invalidNominalType(SwiftNominalTypeDeclaration)
+  case invalidFunctionConvention(SwiftFunctionType)
+}
+
 extension KnownStandardLibraryType {
-  func loweredCType() throws -> CType {
+  /// Determine the primitive C type that corresponds to this C standard
+  /// library type, if there is one.
+  var primitiveCType: CType? {
     switch self {
     case .bool: .integral(.bool)
     case .int: .integral(.ptrdiff_t)
@@ -74,12 +106,8 @@ extension KnownStandardLibraryType {
     case .unsafeRawPointer: .pointer(
       .qualified(const: true, volatile: false, type: .void)
     )
+    case .unsafePointer, .unsafeMutablePointer, .unsafeBufferPointer, .unsafeMutableBufferPointer:
+       nil
     }
   }
 }
-enum CDeclToCLoweringError: Error {
-  case invalidCDeclType(SwiftType)
-  case invalidNominalType(SwiftNominalTypeDeclaration)
-  case invalidFunctionConvention(SwiftFunctionType)
-}
-