Leverage the direct Swift cdecl type <-> C type mapping for lowering

When lowering a Swift function to a cdecl thunk, detect when a given
Swift type is exactly representable in C. In such cases, just keep the
type as written and pass it through without modification. Use this to
allow `@convention(c)` functions to go through untouched.

Author: DougGregor

Sources/JExtractSwift/CDeclLowering/CDeclConversions.swift

@@ -17,6 +17,14 @@ extension ConversionStep {
   /// 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 {
+    // If there is a 1:1 mapping between this Swift type and a C type, then
+    // there is no translation to do.
+    if let cType = try? CType(cdeclType: swiftType) {
+      _ = cType
+      self = .placeholder
+      return
+    }
+
     switch swiftType {
     case .function, .optional:
       throw LoweringError.unhandledType(swiftType)
@@ -29,13 +37,6 @@ extension ConversionStep {
 
     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 {
@@ -100,6 +101,14 @@ extension ConversionStep {
     swiftToCDecl swiftType: SwiftType,
     stdlibTypes: SwiftStandardLibraryTypes
   ) throws {
+    // If there is a 1:1 mapping between this Swift type and a C type, then
+    // there is no translation to do.
+    if let cType = try? CType(cdeclType: swiftType) {
+      _ = cType
+      self = .placeholder
+      return
+    }
+
     switch swiftType {
     case .function, .optional:
       throw LoweringError.unhandledType(swiftType)
@@ -117,13 +126,6 @@ extension ConversionStep {
 
     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 nominal.genericArguments?.first != nil {
           switch knownType {

Sources/JExtractSwift/CDeclLowering/CRepresentation.swift

@@ -16,8 +16,11 @@ 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.
+  /// representable in a Swift `@_cdecl` function, which means that they are
+  /// also directly representable in C. If lowering an arbitrary Swift
+  /// function, first go through Swift -> cdecl lowering. This function
+  /// will throw an error if it encounters a type that is not expressible in
+  /// C.
   init(cdeclType: SwiftType) throws {
     switch cdeclType {
     case .nominal(let nominalType):

Sources/JExtractSwift/CDeclLowering/Swift2JavaTranslator+FunctionLowering.swift

@@ -155,6 +155,22 @@ extension Swift2JavaTranslator {
     convention: SwiftParameterConvention,
     parameterName: String
   ) throws -> LoweredParameters {
+    // If there is a 1:1 mapping between this Swift type and a C type, we just
+    // need to add the corresponding C [arameter.
+    if let cType = try? CType(cdeclType: type), convention != .inout {
+      _ = cType
+      return LoweredParameters(
+        cdeclParameters: [
+          SwiftParameter(
+            convention: convention,
+            parameterName: parameterName,
+            type: type,
+            canBeDirectReturn: true
+          )
+        ]
+      )
+    }
+
     switch type {
     case .function, .optional:
       throw LoweringError.unhandledType(type)
@@ -179,21 +195,6 @@ extension Swift2JavaTranslator {
       // Types from the Swift standard library that we know about.
       if let knownType = nominal.nominalTypeDecl.knownStandardLibraryType,
          convention != .inout {
-        // Swift types that map to primitive types in C. These can be passed
-        // through directly.
-        if knownType.primitiveCType != nil {
-          return LoweredParameters(
-            cdeclParameters: [
-              SwiftParameter(
-                convention: convention,
-                parameterName: parameterName,
-                type: type,
-                canBeDirectReturn: true
-              )
-            ]
-          )
-        }
-
         // Typed pointers are mapped down to their raw forms in cdecl entry
         // points. These can be passed through directly.
         if knownType == .unsafePointer || knownType == .unsafeMutablePointer {

Sources/JExtractSwift/SwiftTypes/SwiftFunctionType.swift

@@ -27,7 +27,12 @@ struct SwiftFunctionType: Equatable {
 
 extension SwiftFunctionType: CustomStringConvertible {
   var description: String {
-    return  "(\(parameters.map { $0.descriptionInType } )) -> \(resultType.description)"
+    let parameterString = parameters.map { $0.descriptionInType }.joined(separator: ", ")
+    let conventionPrefix = switch convention {
+    case .c: "@convention(c) "
+    case .swift: ""
+    }
+    return  "\(conventionPrefix)(\(parameterString)) -> \(resultType.description)"
   }
 }
 

Sources/JExtractSwift/SwiftTypes/SwiftParameter.swift

@@ -64,8 +64,10 @@ extension SwiftParameter {
     var type = node.type
     var convention = SwiftParameterConvention.byValue
     if let attributedType = type.as(AttributedTypeSyntax.self) {
+      var sawUnknownSpecifier = false
       for specifier in attributedType.specifiers {
         guard case .simpleTypeSpecifier(let simple) = specifier else {
+          sawUnknownSpecifier = true
           continue
         }
 
@@ -75,13 +77,15 @@ extension SwiftParameter {
         case .keyword(.inout):
           convention = .inout
         default:
+          sawUnknownSpecifier = true
           break
         }
       }
 
       // Ignore anything else in the attributed type.
-      // FIXME: We might want to check for these and ignore them.
-      type = attributedType.baseType
+      if !sawUnknownSpecifier && attributedType.attributes.isEmpty {
+        type = attributedType.baseType
+      }
     }
     self.convention = convention
 

Sources/JExtractSwift/SwiftTypes/SwiftType.swift

@@ -129,12 +129,12 @@ extension SwiftType {
       // Only recognize the "@convention(c)" and "@convention(swift)" attributes, and
       // then only on function types.
       // FIXME: This string matching is a horrible hack.
-      switch attributedType.trimmedDescription {
+      switch attributedType.attributes.trimmedDescription {
       case "@convention(c)", "@convention(swift)":
         let innerType = try SwiftType(attributedType.baseType, symbolTable: symbolTable)
         switch innerType {
         case .function(var functionType):
-          let isConventionC = attributedType.trimmedDescription == "@convention(c)"
+          let isConventionC = attributedType.attributes.trimmedDescription == "@convention(c)"
           let convention: SwiftFunctionType.Convention = isConventionC ? .c : .swift
           functionType.convention = convention
           self = .function(functionType)

Tests/JExtractSwiftTests/FunctionLoweringTests.swift

@@ -296,4 +296,21 @@ final class FunctionLoweringTests {
       expectedCFunction: "c_getBufferPointer(void* _result_pointer, void* _result_count)"
     )
   }
+
+  @Test("Lowering C function types")
+  func lowerFunctionTypes() throws {
+    // FIXME: C pretty printing isn't handling parameters of function pointer
+    // type yet.
+    try assertLoweredFunction("""
+      func doSomething(body: @convention(c) (Int32) -> Double) { }
+      """,
+      expectedCDecl: """
+      @_cdecl("c_doSomething")
+      public func c_doSomething(_ body: @convention(c) (Int32) -> Double) {
+        doSomething(body: body)
+      }
+      """,
+      expectedCFunction: "void c_doSomething(double* body(int32_t))"
+    )
+  }
 }