[JExtract] Lower generic parameters conforming to some protocols

rintaro · rintaro · commit 9c613be30430 · 2025-07-30T12:44:00.000-07:00
diff --git a/Sources/JExtractSwiftLib/FFM/CDeclLowering/FFMSwift2JavaGenerator+FunctionLowering.swift b/Sources/JExtractSwiftLib/FFM/CDeclLowering/FFMSwift2JavaGenerator+FunctionLowering.swift
@@ -98,18 +98,22 @@ struct CdeclLowering {
       try lowerParameter(
         selfParameter.type,
         convention: selfParameter.convention,
-        parameterName: selfParameter.parameterName ?? "self"
+        parameterName: selfParameter.parameterName ?? "self",
+        genericParameters: signature.genericParameters,
+        genericRequirements: signature.genericRequirements
       )
     case nil, .initializer(_), .staticMethod(_):
       nil
     }
 
     // Lower all of the parameters.
     let loweredParameters = try signature.parameters.enumerated().map { (index, param) in
-      try lowerParameter(
+      return try lowerParameter(
         param.type,
         convention: param.convention,
-        parameterName: param.parameterName ?? "_\(index)"
+        parameterName: param.parameterName ?? "_\(index)",
+        genericParameters: signature.genericParameters,
+        genericRequirements: signature.genericRequirements
       )
     }
 
@@ -142,7 +146,9 @@ struct CdeclLowering {
   func lowerParameter(
     _ type: SwiftType,
     convention: SwiftParameterConvention,
-    parameterName: String
+    parameterName: String,
+    genericParameters: [SwiftGenericParameterDeclaration],
+    genericRequirements: [SwiftGenericRequirement]
   ) throws -> LoweredParameter {
     // If there is a 1:1 mapping between this Swift type and a C type, we just
     // return it.
@@ -257,7 +263,7 @@ struct CdeclLowering {
           guard let genericArgs = nominal.genericArguments, genericArgs.count == 1 else {
             throw LoweringError.unhandledType(type)
           }
-          return try lowerOptionalParameter(genericArgs[0], convention: convention, parameterName: parameterName)
+          return try lowerOptionalParameter(genericArgs[0], convention: convention, parameterName: parameterName, genericParameters: genericParameters, genericRequirements: genericRequirements)
 
         case .string:
           // 'String' is passed in by C string. i.e. 'UnsafePointer<Int8>' ('const uint8_t *')
@@ -300,7 +306,7 @@ struct CdeclLowering {
 
     case .tuple(let tuple):
       if tuple.count == 1 {
-        return try lowerParameter(tuple[0], convention: convention, parameterName: parameterName)
+        return try lowerParameter(tuple[0], convention: convention, parameterName: parameterName, genericParameters: genericParameters, genericRequirements: genericRequirements)
       }
       if convention == .inout {
         throw LoweringError.inoutNotSupported(type)
@@ -310,7 +316,7 @@ struct CdeclLowering {
       for (idx, element) in tuple.enumerated() {
         // FIXME: Use tuple element label.
         let cdeclName = "\(parameterName)_\(idx)"
-        let lowered = try lowerParameter(element, convention: convention, parameterName: cdeclName)
+        let lowered = try lowerParameter(element, convention: convention, parameterName: cdeclName, genericParameters: genericParameters, genericRequirements: genericRequirements)
 
         parameters.append(contentsOf: lowered.cdeclParameters)
         conversions.append(lowered.conversion)
@@ -330,23 +336,14 @@ struct CdeclLowering {
         conversion: conversion
       )
 
-    case .opaque(let proto), .existential(let proto):
-      // If the protocol has a known representative implementation, e.g. `String` for `StringProtocol`
-      // Translate it as the concrete type.
-      // NOTE: This is a temporary workaround until we add support for generics.
-      if
-        let knownProtocol = proto.asNominalTypeDeclaration?.knownTypeKind,
-        let concreteTy = knownTypes.representativeType(of: knownProtocol)
-      {
-        return try lowerParameter(concreteTy, convention: convention, parameterName: parameterName)
+    case .opaque, .existential, .genericParameter:
+      if let concreteTy = representativeConcreteType(type, genericParameters: genericParameters, genericRequirements: genericRequirements) {
+        return try lowerParameter(concreteTy, convention: convention, parameterName: parameterName, genericParameters: genericParameters, genericRequirements: genericRequirements)
       }
       throw LoweringError.unhandledType(type)
 
     case .optional(let wrapped):
-      return try lowerOptionalParameter(wrapped, convention: convention, parameterName: parameterName)
-
-    case .genericParameter:
-      throw LoweringError.unhandledType(type)
+      return try lowerOptionalParameter(wrapped, convention: convention, parameterName: parameterName, genericParameters: genericParameters, genericRequirements: genericRequirements)
     }
   }
 
@@ -357,7 +354,9 @@ struct CdeclLowering {
   func lowerOptionalParameter(
     _ wrappedType: SwiftType,
     convention: SwiftParameterConvention,
-    parameterName: String
+    parameterName: String,
+    genericParameters: [SwiftGenericParameterDeclaration],
+    genericRequirements: [SwiftGenericRequirement]
   ) throws -> LoweredParameter {
     // If there is a 1:1 mapping between this Swift type and a C type, lower it to 'UnsafePointer<T>?'
     if let _ = try? CType(cdeclType: wrappedType) {
@@ -401,26 +400,59 @@ struct CdeclLowering {
         conversion: .pointee(.typedPointer(.optionalChain(.placeholder), swiftType: wrappedType))
       )
 
-    case .existential(let proto), .opaque(let proto):
-      if
-        let knownProtocol = proto.asNominalTypeDeclaration?.knownTypeKind,
-        let concreteTy = knownTypes.representativeType(of: knownProtocol)
-      {
-        return try lowerOptionalParameter(concreteTy, convention: convention, parameterName: parameterName)
+    case .existential, .opaque, .genericParameter:
+      if let concreteTy = representativeConcreteType(wrappedType, genericParameters: genericParameters, genericRequirements: genericRequirements) {
+        return try lowerOptionalParameter(concreteTy, convention: convention, parameterName: parameterName, genericParameters: genericParameters, genericRequirements: genericRequirements)
       }
       throw LoweringError.unhandledType(.optional(wrappedType))
       
     case .tuple(let tuple):
       if tuple.count == 1 {
-        return try lowerOptionalParameter(tuple[0], convention: convention, parameterName: parameterName)
+        return try lowerOptionalParameter(tuple[0], convention: convention, parameterName: parameterName, genericParameters: genericParameters, genericRequirements: genericRequirements)
       }
       throw LoweringError.unhandledType(.optional(wrappedType))
 
-    case .function, .metatype, .optional, .genericParameter:
+    case .function, .metatype, .optional:
       throw LoweringError.unhandledType(.optional(wrappedType))
     }
   }
 
+  /// Returns a concrete type if the specified type is a generic parameter that
+  /// conforms to a protocol with representative concrete type.
+  func representativeConcreteType(
+    _ type: SwiftType,
+    genericParameters: [SwiftGenericParameterDeclaration],
+    genericRequirements: [SwiftGenericRequirement]
+  ) -> SwiftType? {
+    var maybeProto: SwiftType? = nil
+    switch type {
+    case .existential(let proto), .opaque(let proto):
+      maybeProto = proto
+    case .genericParameter(let genericParam):
+      // If the type is a generic parameter declared in this function and
+      // conforms to a protocol with representative concrete type, use it.
+      if genericParameters.contains(genericParam) {
+        for requirement in genericRequirements {
+          if case .inherits(let left, let right) = requirement, left == type {
+            guard maybeProto == nil else {
+              // multiple requirements on the generic parameter.
+              return nil
+            }
+            maybeProto = right
+            break
+          }
+        }
+      }
+    default:
+      return nil
+    }
+
+    if let knownProtocol = maybeProto?.asNominalTypeDeclaration?.knownTypeKind {
+      return knownTypes.representativeType(of: knownProtocol)
+    }
+    return nil
+  }
+
   /// Lower a Swift function type (i.e. closure) to cdecl function type.
   ///
   /// - Parameters:
@@ -757,7 +789,9 @@ public struct LoweredFunctionSignature: Equatable {
       selfParameter: nil,
       parameters: allLoweredParameters,
       result: SwiftResult(convention: .direct, type: result.cdeclResultType),
-      effectSpecifiers: []
+      effectSpecifiers: [],
+      genericParameters: [],
+      genericRequirements: []
     )
   }
 }
diff --git a/Sources/JExtractSwiftLib/SwiftTypes/SwiftFunctionSignature.swift b/Sources/JExtractSwiftLib/SwiftTypes/SwiftFunctionSignature.swift
@@ -24,24 +24,26 @@ enum SwiftGenericRequirement: Equatable {
 /// parameters and return type.
 public struct SwiftFunctionSignature: Equatable {
   var selfParameter: SwiftSelfParameter?
-  var genericParameters: [SwiftTypeDeclaration]
   var parameters: [SwiftParameter]
   var result: SwiftResult
   var effectSpecifiers: [SwiftEffectSpecifier]
+  var genericParameters: [SwiftGenericParameterDeclaration]
   var genericRequirements: [SwiftGenericRequirement]
 
   init(
     selfParameter: SwiftSelfParameter? = nil,
     parameters: [SwiftParameter],
     result: SwiftResult,
-    effectSpecifiers: [SwiftEffectSpecifier]
+    effectSpecifiers: [SwiftEffectSpecifier],
+    genericParameters: [SwiftGenericParameterDeclaration],
+    genericRequirements: [SwiftGenericRequirement]
   ) {
     self.selfParameter = selfParameter
     self.parameters = parameters
     self.result = result
     self.effectSpecifiers = effectSpecifiers
-    self.genericParameters = []
-    self.genericRequirements = []
+    self.genericParameters = genericParameters
+    self.genericRequirements = genericRequirements
   }
 }
 
@@ -79,11 +81,11 @@ extension SwiftFunctionSignature {
       throw SwiftFunctionTranslationError.failableInitializer(node)
     }
 
-    // Prohibit generics for now.
-    if let generics = node.genericParameterClause {
-      throw SwiftFunctionTranslationError.generic(generics)
-    }
-
+    let (genericParams, genericRequirements) = try Self.translateGenericParameters(
+      parameterClause: node.genericParameterClause,
+      whereClause: node.genericWhereClause,
+      lookupContext: lookupContext
+    )
     let (parameters, effectSpecifiers) = try Self.translateFunctionSignature(
       node.signature,
       lookupContext: lookupContext
@@ -93,7 +95,9 @@ extension SwiftFunctionSignature {
       selfParameter: .initializer(enclosingType),
       parameters: parameters,
       result: SwiftResult(convention: .direct, type: enclosingType),
-      effectSpecifiers: effectSpecifiers
+      effectSpecifiers: effectSpecifiers,
+      genericParameters: genericParams,
+      genericRequirements: genericRequirements
     )
   }
 
@@ -103,9 +107,11 @@ extension SwiftFunctionSignature {
     lookupContext: SwiftTypeLookupContext
   ) throws {
     // Prohibit generics for now.
-    if let generics = node.genericParameterClause {
-      throw SwiftFunctionTranslationError.generic(generics)
-    }
+    let (genericParams, genericRequirements) = try Self.translateGenericParameters(
+      parameterClause: node.genericParameterClause,
+      whereClause: node.genericWhereClause,
+      lookupContext: lookupContext,
+    )
 
     // If this is a member of a type, so we will have a self parameter. Figure out the
     // type and convention for the self parameter.
@@ -155,7 +161,68 @@ extension SwiftFunctionSignature {
       result = .void
     }
 
-    self.init(selfParameter: selfParameter, parameters: parameters, result: result, effectSpecifiers: effectSpecifiers)
+    self.init(
+      selfParameter: selfParameter,
+      parameters: parameters,
+      result: result,
+      effectSpecifiers: effectSpecifiers,
+      genericParameters: genericParams,
+      genericRequirements: genericRequirements
+    )
+  }
+
+  static func translateGenericParameters(
+    parameterClause: GenericParameterClauseSyntax?,
+    whereClause: GenericWhereClauseSyntax?,
+    lookupContext: SwiftTypeLookupContext,
+  ) throws -> (parameters: [SwiftGenericParameterDeclaration], requirements: [SwiftGenericRequirement]) {
+    var params: [SwiftGenericParameterDeclaration] = []
+    var requirements: [SwiftGenericRequirement] = []
+
+    // Parameter clause
+    if let parameterClause {
+      for parameterNode in parameterClause.parameters {
+        guard parameterNode.specifier == nil else {
+          throw SwiftFunctionTranslationError.genericParameterSpecifier(parameterNode)
+        }
+        let param = try lookupContext.typeDeclaration(for: parameterNode) as! SwiftGenericParameterDeclaration
+        params.append(param)
+        if let inheritedNode = parameterNode.inheritedType {
+          let inherited = try SwiftType(inheritedNode, lookupContext: lookupContext)
+          requirements.append(.inherits(.genericParameter(param), inherited))
+        }
+      }
+    }
+
+    // Where clause
+    if let whereClause {
+      for requirementNode in whereClause.requirements {
+        let requirement: SwiftGenericRequirement
+        switch requirementNode.requirement {
+        case .conformanceRequirement(let conformance):
+          requirement = .inherits(
+            try SwiftType(conformance.leftType, lookupContext: lookupContext),
+            try SwiftType(conformance.rightType, lookupContext: lookupContext)
+          )
+        case .sameTypeRequirement(let sameType):
+          guard let leftType = sameType.leftType.as(TypeSyntax.self) else {
+            throw SwiftFunctionTranslationError.expressionInGenericRequirement(requirementNode)
+          }
+          guard let rightType = sameType.rightType.as(TypeSyntax.self) else {
+            throw SwiftFunctionTranslationError.expressionInGenericRequirement(requirementNode)
+          }
+          requirement = .equals(
+            try SwiftType(leftType, lookupContext: lookupContext),
+            try SwiftType(rightType, lookupContext: lookupContext)
+            )
+        case .layoutRequirement:
+          throw SwiftFunctionTranslationError.layoutRequirement(requirementNode)
+        }
+        requirements.append(requirement)
+      }
+    }
+
+    return (params, requirements)
   }
 
   /// Translate the function signature, returning the list of translated
@@ -310,4 +377,7 @@ enum SwiftFunctionTranslationError: Error {
   case multipleBindings(VariableDeclSyntax)
   case missingTypeAnnotation(VariableDeclSyntax)
   case unsupportedAccessor(AccessorDeclSyntax)
+  case genericParameterSpecifier(GenericParameterSyntax)
+  case expressionInGenericRequirement(GenericRequirementSyntax)
+  case layoutRequirement(GenericRequirementSyntax)
 }
diff --git a/Sources/JExtractSwiftLib/SwiftTypes/SwiftType.swift b/Sources/JExtractSwiftLib/SwiftTypes/SwiftType.swift
@@ -333,7 +333,7 @@ extension SwiftType {
     self = .nominal(
       SwiftNominalType(
         parent: parent?.asNominalType,
-        nominalTypeDecl: nominalTypeDecl as! SwiftNominalTypeDeclaration,
+        nominalTypeDecl: nominalTypeDecl,
         genericArguments: nil
       )
     )
diff --git a/Tests/JExtractSwiftTests/FunctionLoweringTests.swift b/Tests/JExtractSwiftTests/FunctionLoweringTests.swift
@@ -404,6 +404,27 @@ final class FunctionLoweringTests {
       """)
   }
 
+  @Test("Lowering generic parameters")
+  func genericParam() throws {
+    try assertLoweredFunction(
+      """
+      func fn<T, U: DataProtocol>(x: T, y: U?) where T: DataProtocol
+      """,
+      sourceFile: """
+      import Foundation
+      """,
+      expectedCDecl: """
+      @_cdecl("c_fn")
+      public func c_fn(_ x: UnsafeRawPointer, _ y: UnsafeRawPointer?) {
+        fn(x: x.assumingMemoryBound(to: Data.self).pointee, y: y?.assumingMemoryBound(to: Data.self).pointee)
+      }
+      """,
+      expectedCFunction: """
+      void c_fn(const void *x, const void *y)
+      """
+    )
+  }
+
   @Test("Lowering read accessor")
   func lowerGlobalReadAccessor() throws {
     try assertLoweredVariableAccessor(

Original file line number	Diff line number	Diff line change
`@@ -333,7 +333,7 @@ extension SwiftType {`
`333`	`333`	`self = .nominal(`
`334`	`334`	`SwiftNominalType(`
`335`	`335`	`parent: parent?.asNominalType,`
`336`		`- nominalTypeDecl: nominalTypeDecl as! SwiftNominalTypeDeclaration,`
	`336`	`+ nominalTypeDecl: nominalTypeDecl,`
`337`	`337`	`genericArguments: nil`
`338`	`338`	`)`
`339`	`339`	`)`