Lower initializers and static methods to C declarations

Author: DougGregor

Sources/JExtractSwift/CDeclLowering/Swift2JavaTranslator+FunctionLowering.swift

@@ -33,6 +33,22 @@ extension Swift2JavaTranslator {
     return try lowerFunctionSignature(signature)
   }
 
+  /// Lower the given initializer to a C-compatible entrypoint,
+  /// providing all of the mappings between the parameter and result types
+  /// of the original function and its `@_cdecl` counterpart.
+  @_spi(Testing)
+  public func lowerFunctionSignature(
+    _ decl: InitializerDeclSyntax,
+    enclosingType: TypeSyntax? = nil
+  ) throws -> LoweredFunctionSignature {
+    let signature = try SwiftFunctionSignature(
+      decl,
+      enclosingType: try enclosingType.map { try SwiftType($0, symbolTable: symbolTable) },
+      symbolTable: symbolTable
+    )
+
+    return try lowerFunctionSignature(signature)
+  }
   /// Lower the given Swift function signature to a Swift @_cdecl function signature,
   /// which is C compatible, and the corresponding Java method signature.
   ///
@@ -75,12 +91,18 @@ extension Swift2JavaTranslator {
       indirectResult = true
     }
 
-    let loweredSelf = try signature.selfParameter.map { selfParameter in
-      try lowerParameter(
-        selfParameter.type,
-        convention: selfParameter.convention,
-        parameterName: selfParameter.parameterName ?? "self"
-      )
+    // Lower the self parameter.
+    let loweredSelf = try signature.selfParameter.flatMap { selfParameter in
+      switch selfParameter {
+      case .instance(let selfParameter):
+        try lowerParameter(
+          selfParameter.type,
+          convention: selfParameter.convention,
+          parameterName: selfParameter.parameterName ?? "self"
+        )
+      case .initializer, .staticMethod:
+        nil
+      }
     }
 
     // Collect all of the lowered parameters for the @_cdecl function.
@@ -112,7 +134,6 @@ extension Swift2JavaTranslator {
     }
 
     let cdeclSignature = SwiftFunctionSignature(
-      isStaticOrClass: false,
       selfParameter: nil,
       parameters: cdeclLoweredParameters,
       result: cdeclResult
@@ -301,7 +322,7 @@ extension LoweredFunctionSignature {
   @_spi(Testing)
   public func cdeclThunk(
     cName: String,
-    inputFunction: FunctionDeclSyntax,
+    swiftFunctionName: String,
     stdlibTypes: SwiftStandardLibraryTypes
   ) -> FunctionDeclSyntax {
     var loweredCDecl = cdecl.createFunctionDecl(cName)
@@ -315,14 +336,33 @@ extension LoweredFunctionSignature {
     // Lower "self", if there is one.
     let parametersToLower: ArraySlice<LoweredParameters>
     let cdeclToOriginalSelf: ExprSyntax?
-    if let originalSelfParam = original.selfParameter {
-      cdeclToOriginalSelf = try! ConversionStep(
-        cdeclToSwift: originalSelfParam.type
-      ).asExprSyntax(
-        isSelf: true,
-        placeholder: originalSelfParam.parameterName ?? "self"
-      )
-      parametersToLower = parameters.dropLast()
+    var initializerType: SwiftType? = nil
+    if let originalSelf = original.selfParameter {
+      switch originalSelf {
+      case .instance(let originalSelfParam):
+        // The instance was provided to the cdecl thunk, so convert it to
+        // its Swift representation.
+        cdeclToOriginalSelf = try! ConversionStep(
+          cdeclToSwift: originalSelfParam.type
+        ).asExprSyntax(
+          isSelf: true,
+          placeholder: originalSelfParam.parameterName ?? "self"
+        )
+        parametersToLower = parameters.dropLast()
+
+      case .staticMethod(let selfType):
+        // Static methods use the Swift type as "self", but there is no
+        // corresponding cdecl parameter.
+        cdeclToOriginalSelf = "\(raw: selfType.description)"
+        parametersToLower = parameters[...]
+
+      case .initializer(let selfType):
+        // Initializers use the Swift type to create the instance. Save it
+        // for later. There is no corresponding cdecl parameter.
+        initializerType = selfType
+        cdeclToOriginalSelf = nil
+        parametersToLower = parameters[...]
+      }
     } else {
       cdeclToOriginalSelf = nil
       parametersToLower = parameters[...]
@@ -346,9 +386,14 @@ extension LoweredFunctionSignature {
     }
 
     // Form the call expression.
-    var callExpression: ExprSyntax = "\(inputFunction.name)(\(raw: cdeclToOriginalArguments.joined(separator: ", ")))"
-    if let cdeclToOriginalSelf {
-      callExpression = "\(cdeclToOriginalSelf).\(callExpression)"
+    let callArguments: ExprSyntax = "(\(raw: cdeclToOriginalArguments.joined(separator: ", ")))"
+    let callExpression: ExprSyntax
+    if let initializerType {
+      callExpression = "\(raw: initializerType.description)\(callArguments)"
+    } else if let cdeclToOriginalSelf {
+      callExpression = "\(cdeclToOriginalSelf).\(raw: swiftFunctionName)\(callArguments)"
+    } else {
+      callExpression = "\(raw: swiftFunctionName)\(callArguments)"
     }
 
     // Handle the return.

Sources/JExtractSwift/SwiftTypes/SwiftFunctionSignature.swift

@@ -19,13 +19,25 @@ import SwiftSyntaxBuilder
 /// parameters and return type.
 @_spi(Testing)
 public struct SwiftFunctionSignature: Equatable {
-  // FIXME: isStaticOrClass probably shouldn't be here?
-  var isStaticOrClass: Bool
-  var selfParameter: SwiftParameter?
+  var selfParameter: SwiftSelfParameter?
   var parameters: [SwiftParameter]
   var result: SwiftResult
 }
 
+/// Describes the "self" parameter of a Swift function signature.
+enum SwiftSelfParameter: Equatable {
+  /// 'self' is an instance parameter.
+  case instance(SwiftParameter)
+
+  /// 'self' is a metatype for a static method. We only need the type to
+  /// form the call.
+  case staticMethod(SwiftType)
+
+  /// 'self' is the type for a call to an initializer. We only need the type
+  /// to form the call.
+  case initializer(SwiftType)
+}
+
 extension SwiftFunctionSignature {
   /// Create a function declaration with the given name that has this
   /// signature.
@@ -49,6 +61,33 @@ extension SwiftFunctionSignature {
 }
 
 extension SwiftFunctionSignature {
+  init(
+    _ node: InitializerDeclSyntax,
+    enclosingType: SwiftType?,
+    symbolTable: SwiftSymbolTable
+  ) throws {
+    guard let enclosingType else {
+      throw SwiftFunctionTranslationError.missingEnclosingType(node)
+    }
+
+    // We do not yet support failable initializers.
+    if node.optionalMark != nil {
+      throw SwiftFunctionTranslationError.failableInitializer(node)
+    }
+
+    // Prohibit generics for now.
+    if let generics = node.genericParameterClause {
+      throw SwiftFunctionTranslationError.generic(generics)
+    }
+
+    self.selfParameter = .initializer(enclosingType)
+    self.result = SwiftResult(convention: .direct, type: enclosingType)
+    self.parameters = try Self.translateFunctionSignature(
+      node.signature,
+      symbolTable: symbolTable
+    )
+  }
+
   init(
     _ node: FunctionDeclSyntax,
     enclosingType: SwiftType?,
@@ -59,40 +98,36 @@ extension SwiftFunctionSignature {
     if let enclosingType {
       var isMutating = false
       var isConsuming = false
-      var isStaticOrClass = false
+      var isStatic = false
       for modifier in node.modifiers {
         switch modifier.name.tokenKind {
         case .keyword(.mutating): isMutating = true
-        case .keyword(.static), .keyword(.class): isStaticOrClass = true
+        case .keyword(.static): isStatic = true
         case .keyword(.consuming): isConsuming = true
+        case .keyword(.class): throw SwiftFunctionTranslationError.classMethod(modifier.name)
         default: break
         }
       }
 
-      if isStaticOrClass {
-        self.selfParameter = SwiftParameter(
-          convention: .byValue,
-          type: .metatype(
-            enclosingType
-          )
-        )
+      if isStatic {
+        self.selfParameter = .staticMethod(enclosingType)
       } else {
-        self.selfParameter = SwiftParameter(
-          convention: isMutating ? .inout : isConsuming ? .consuming : .byValue,
-          type: enclosingType
+        self.selfParameter = .instance(
+          SwiftParameter(
+            convention: isMutating ? .inout : isConsuming ? .consuming : .byValue,
+            type: enclosingType
+          )
         )
       }
-
-      self.isStaticOrClass = isStaticOrClass
     } else {
       self.selfParameter = nil
-      self.isStaticOrClass = false
     }
 
     // Translate the parameters.
-    self.parameters = try node.signature.parameterClause.parameters.map { param in
-      try SwiftParameter(param, symbolTable: symbolTable)
-    }
+    self.parameters = try Self.translateFunctionSignature(
+      node.signature,
+      symbolTable: symbolTable
+    )
 
     // Translate the result type.
     if let resultType = node.signature.returnClause?.type {
@@ -104,17 +139,28 @@ extension SwiftFunctionSignature {
       self.result = SwiftResult(convention: .direct, type: .tuple([]))
     }
 
+    // Prohibit generics for now.
+    if let generics = node.genericParameterClause {
+      throw SwiftFunctionTranslationError.generic(generics)
+    }
+  }
+
+  /// Translate the function signature, returning the list of translated
+  /// parameters.
+  static func translateFunctionSignature(
+    _ signature: FunctionSignatureSyntax,
+    symbolTable: SwiftSymbolTable
+  ) throws -> [SwiftParameter] {
     // FIXME: Prohibit effects for now.
-    if let throwsClause = node.signature.effectSpecifiers?.throwsClause {
+    if let throwsClause = signature.effectSpecifiers?.throwsClause {
       throw SwiftFunctionTranslationError.throws(throwsClause)
     }
-    if let asyncSpecifier = node.signature.effectSpecifiers?.asyncSpecifier {
+    if let asyncSpecifier = signature.effectSpecifiers?.asyncSpecifier {
       throw SwiftFunctionTranslationError.async(asyncSpecifier)
     }
 
-    // Prohibit generics for now.
-    if let generics = node.genericParameterClause {
-      throw SwiftFunctionTranslationError.generic(generics)
+    return try signature.parameterClause.parameters.map { param in
+      try SwiftParameter(param, symbolTable: symbolTable)
     }
   }
 }
@@ -123,4 +169,7 @@ enum SwiftFunctionTranslationError: Error {
   case `throws`(ThrowsClauseSyntax)
   case async(TokenSyntax)
   case generic(GenericParameterClauseSyntax)
+  case classMethod(TokenSyntax)
+  case missingEnclosingType(InitializerDeclSyntax)
+  case failableInitializer(InitializerDeclSyntax)
 }

Tests/JExtractSwiftTests/Asserts/LoweringAssertions.swift

@@ -42,14 +42,27 @@ func assertLoweredFunction(
 
   translator.prepareForTranslation()
 
-  let inputFunction = inputDecl.cast(FunctionDeclSyntax.self)
-  let loweredFunction = try translator.lowerFunctionSignature(
-    inputFunction,
-    enclosingType: enclosingType
-  )
+  let swiftFunctionName: String
+  let loweredFunction: LoweredFunctionSignature
+  if let inputFunction = inputDecl.as(FunctionDeclSyntax.self) {
+    loweredFunction = try translator.lowerFunctionSignature(
+      inputFunction,
+      enclosingType: enclosingType
+    )
+    swiftFunctionName = inputFunction.name.text
+  } else if let inputInitializer = inputDecl.as(InitializerDeclSyntax.self) {
+    loweredFunction = try translator.lowerFunctionSignature(
+      inputInitializer,
+      enclosingType: enclosingType
+    )
+    swiftFunctionName = "init"
+  } else {
+    fatalError("Unhandling declaration kind for lowering")
+  }
+
   let loweredCDecl = loweredFunction.cdeclThunk(
-    cName: "c_\(inputFunction.name.text)",
-    inputFunction: inputFunction,
+    cName: "c_\(swiftFunctionName)",
+    swiftFunctionName: swiftFunctionName,
     stdlibTypes: translator.swiftStdlibTypes
   )
 
@@ -65,7 +78,7 @@ func assertLoweredFunction(
 
   let cFunction = translator.cdeclToCFunctionLowering(
     loweredFunction.cdecl,
-    cName: "c_\(inputFunction.name.text)"
+    cName: "c_\(swiftFunctionName)"
   )
   #expect(
     cFunction.description == expectedCFunction,