Implement lowering of Swift cdecl functions to C functions

Leverage the new C type system so that we can lower Swift cdecl
functions down to their C representation. This could be used to
generate C headers (albeit ugly ones) in the future, but for now is
part of the validation of lowering Swift functions to cdecl thunks.

Author: DougGregor

Sources/JExtractSwift/CTypes/CType.swift

@@ -195,3 +195,16 @@ extension CType: CustomStringConvertible {
     print(placeholder: nil)
   }
 }
+
+extension CType {
+  /// Apply the rules for function parameter decay to produce the resulting
+  /// decayed type. For example, this will adjust a function type to a
+  /// pointer-to-function type.
+  var parameterDecay: CType {
+    switch self {
+    case .floating, .integral, .pointer, .qualified, .tag, .void: self
+
+    case .function: .pointer(self)
+    }
+  }
+}

Sources/JExtractSwift/Swift2JavaTranslator+FunctionLowering.swift

@@ -145,7 +145,7 @@ extension Swift2JavaTranslator {
             parameterName: parameterName,
             type: .nominal(
               SwiftNominalType(
-                nominalTypeDecl: swiftStdlibTypes.unsafeRawPointerDecl
+                nominalTypeDecl: swiftStdlibTypes[.unsafeRawPointer]
               )
             )
           )
@@ -187,8 +187,8 @@ extension Swift2JavaTranslator {
             type: .nominal(
               SwiftNominalType(
                 nominalTypeDecl: mutable
-                  ? swiftStdlibTypes.unsafeMutableRawPointerDecl
-                  : swiftStdlibTypes.unsafeRawPointerDecl
+                  ? swiftStdlibTypes[.unsafeMutableRawPointer]
+                  : swiftStdlibTypes[.unsafeRawPointer]
               )
             )
           )
@@ -276,8 +276,8 @@ extension Swift2JavaTranslator {
 
     // At the @_cdecl level, make everything a raw pointer.
     let cdeclPointerType = mutable
-      ? swiftStdlibTypes.unsafeMutableRawPointerDecl
-      : swiftStdlibTypes.unsafeRawPointerDecl
+      ? swiftStdlibTypes[.unsafeMutableRawPointer]
+      : swiftStdlibTypes[.unsafeRawPointer]
     var cdeclToOriginal: LoweringStep
     switch (requiresArgument, hasCount) {
     case (false, false):
@@ -327,7 +327,7 @@ extension Swift2JavaTranslator {
             convention: convention,
             parameterName: parameterName + "_count",
             type: SwiftType.nominal(
-              SwiftNominalType(nominalTypeDecl: swiftStdlibTypes.intDecl)
+              SwiftNominalType(nominalTypeDecl: swiftStdlibTypes[.int])
             )
           ),
           .SwiftInt
@@ -353,6 +353,33 @@ extension Swift2JavaTranslator {
       cdeclParameters: lowered.map(\.0)
     )
   }
+
+  /// Given a Swift function signature that represents a @_cdecl function,
+  /// produce the equivalent C function with the given name.
+  ///
+  /// Lowering to a @_cdecl function should never produce a
+  @_spi(Testing)
+  public func cdeclToCFunctionLowering(
+    _ cdeclSignature: SwiftFunctionSignature,
+    cName: String
+  ) -> CFunction {
+    assert(cdeclSignature.selfParameter == nil)
+
+    let cResultType = try! swiftStdlibTypes.cdeclToCLowering(cdeclSignature.result.type)
+    let cParameters = cdeclSignature.parameters.map { parameter in
+      CParameter(
+        name: parameter.parameterName,
+        type: try! swiftStdlibTypes.cdeclToCLowering(parameter.type).parameterDecay
+      )
+    }
+
+    return CFunction(
+      resultType: cResultType,
+      name: cName,
+      parameters: cParameters,
+      isVariadic: false
+    )
+  }
 }
 
 struct LabeledArgument<Element> {

Sources/JExtractSwift/SwiftTypes/SwiftStandardLibraryTypes+CLowering.swift

@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SwiftStandardLibraryTypes {
+  /// 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 {
+    case .nominal(let nominalType):
+      if let knownType = self[nominalType.nominalTypeDecl] {
+        return try knownType.loweredCType()
+      }
+
+      throw CDeclToCLoweringError.invalidNominalType(nominalType.nominalTypeDecl)
+
+    case .function(let functionType):
+      switch functionType.convention {
+      case .swift:
+        throw CDeclToCLoweringError.invalidFunctionConvention(functionType)
+
+      case .c:
+        let resultType = try cdeclToCLowering(functionType.resultType)
+        let parameterTypes = try functionType.parameters.map { param in
+          try cdeclToCLowering(param.type)
+        }
+
+        return .function(
+          resultType: resultType,
+          parameters: parameterTypes,
+          variadic: false
+        )
+      }
+
+    case .tuple([]):
+      return .void
+
+    case .metatype, .optional, .tuple:
+      throw CDeclToCLoweringError.invalidCDeclType(swiftType)
+    }
+  }
+}
+
+extension KnownStandardLibraryType {
+  func loweredCType() throws -> CType {
+    switch self {
+    case .bool: .integral(.bool)
+    case .int: .integral(.ptrdiff_t)
+    case .uint: .integral(.size_t)
+    case .int8: .integral(.signed(bits: 8))
+    case .uint8: .integral(.unsigned(bits: 8))
+    case .int16: .integral(.signed(bits: 16))
+    case .uint16: .integral(.unsigned(bits: 16))
+    case .int32: .integral(.signed(bits: 32))
+    case .uint32: .integral(.unsigned(bits: 32))
+    case .int64: .integral(.signed(bits: 64))
+    case .uint64: .integral(.unsigned(bits: 64))
+    case .float: .floating(.float)
+    case .double: .floating(.double)
+    case .unsafeMutableRawPointer: .pointer(.void)
+    case .unsafeRawPointer: .pointer(
+      .qualified(const: true, volatile: false, type: .void)
+    )
+    }
+  }
+}
+enum CDeclToCLoweringError: Error {
+  case invalidCDeclType(SwiftType)
+  case invalidNominalType(SwiftNominalTypeDeclaration)
+  case invalidFunctionConvention(SwiftFunctionType)
+}
+