add support for associated values

Author: madsodgaard

Samples/JExtractJNISampleApp/Sources/MySwiftLibrary/Vehicle.swift

@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 public enum Vehicle {
-  case car
   case bicycle
+  case car(String)
+  case motorbike(String, horsePower: Int64)
 }

Samples/JExtractJNISampleApp/src/test/java/com/example/swift/VehicleTest.java

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 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
+//
+//===----------------------------------------------------------------------===//
+
+package com.example.swift;
+
+import org.junit.jupiter.api.Test;
+import org.swift.swiftkit.core.ConfinedSwiftMemorySession;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class VehicleTest {
+    @Test
+    void bicycle() {
+        try (var arena = new ConfinedSwiftMemorySession()) {
+            Vehicle vehicle = Vehicle.bicycle(arena);
+            assertNotNull(vehicle);
+        }
+    }
+
+    @Test
+    void car() {
+        try (var arena = new ConfinedSwiftMemorySession()) {
+            Vehicle vehicle = Vehicle.car("Porsche 911", arena);
+            assertNotNull(vehicle);
+        }
+    }
+
+    @Test
+    void motorbike() {
+        try (var arena = new ConfinedSwiftMemorySession()) {
+            Vehicle vehicle = Vehicle.motorbike("Yamaha", 750, arena);
+            assertNotNull(vehicle);
+        }
+    }
+}

Sources/JExtractSwiftLib/Convenience/SwiftSyntax+Extensions.swift

@@ -253,6 +253,8 @@ extension DeclSyntaxProtocol {
           }
         ))
         .triviaSanitizedDescription
+    case .enumCaseDecl(let node):
+      node.triviaSanitizedDescription
     default:
       fatalError("unimplemented \(self.kind)")
     }

Sources/JExtractSwiftLib/FFM/CDeclLowering/FFMSwift2JavaGenerator+FunctionLowering.swift

@@ -835,6 +835,10 @@ extension LoweredFunctionSignature {
     case .setter:
       assert(paramExprs.count == 1)
       resultExpr = "\(callee) = \(paramExprs[0])"
+
+    case .enumCase:
+      // This should not be called, but let's fatalError.
+      fatalError("Enum cases are not supported with FFM.")
     }
 
     // Lower the result.

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift

@@ -146,7 +146,7 @@ extension FFMSwift2JavaGenerator {
       let javaName = switch decl.apiKind {
       case .getter: decl.javaGetterName
       case .setter: decl.javaSetterName
-      case .function, .initializer: decl.name
+      case .function, .initializer, .enumCase: decl.name
       }
 
       // Signature.

Sources/JExtractSwiftLib/ImportedDecls.swift

@@ -22,6 +22,7 @@ package enum SwiftAPIKind {
   case initializer
   case getter
   case setter
+  case enumCase
 }
 
 /// Describes a Swift nominal type (e.g., a class, struct, enum) that has been
@@ -54,16 +55,21 @@ public final class ImportedEnumCase: ImportedDecl, CustomStringConvertible {
   /// The enum parameters
   var parameters: [SwiftEnumCaseParameter]
 
-  init(name: String, parameters: [SwiftEnumCaseParameter]) {
+  /// A function that represents the Swift static "initializer" for cases
+  var caseFunction: ImportedFunc
+
+  init(name: String, parameters: [SwiftEnumCaseParameter], caseFunction: ImportedFunc) {
     self.name = name
     self.parameters = parameters
+    self.caseFunction = caseFunction
   }
 
   public var description: String {
     """
     ImportedEnumCase {
       name: \(name),
-      parameters: \(parameters)
+      parameters: \(parameters),
+      caseFunction: \(caseFunction)
     }
     """
   }
@@ -136,6 +142,7 @@ public final class ImportedFunc: ImportedDecl, CustomStringConvertible {
     let prefix = switch self.apiKind {
     case .getter: "getter:"
     case .setter: "setter:"
+    case .enumCase: "case:"
     case .function, .initializer: ""
     }
 

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -193,13 +193,24 @@ extension JNISwift2JavaGenerator {
   }
 
   private func printEnumHelpers(_ printer: inout CodePrinter, _ decl: ImportedNominalType) {
+    // TODO: Move this to seperate file +Enum?
+    printEnumDiscriminator(&printer, decl)
+    printer.println()
+    printEnumStaticInitializers(&printer, decl)
+  }
+
+  private func printEnumDiscriminator(_ printer: inout CodePrinter, _ decl: ImportedNominalType) {
     printer.printBraceBlock("public enum Discriminator") { printer in
       printer.print(
         decl.cases.map { $0.name.uppercased() }.joined(separator: ",\n")
       )
     }
+  }
 
-    printer.println()
+  private func printEnumStaticInitializers(_ printer: inout CodePrinter, _ decl: ImportedNominalType) {
+    for enumCase in decl.cases {
+      printFunctionDowncallMethods(&printer, enumCase.caseFunction)
+    }
   }
 
   private func printFunctionDowncallMethods(

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -61,7 +61,7 @@ extension JNISwift2JavaGenerator {
       let javaName = switch decl.apiKind {
       case .getter: decl.javaGetterName
       case .setter: decl.javaSetterName
-      case .function, .initializer: decl.name
+      case .function, .initializer, .enumCase: decl.name
       }
 
       // Swift -> Java
@@ -137,7 +137,7 @@ extension JNISwift2JavaGenerator {
       parentName: String
     ) throws -> TranslatedFunctionSignature {
       let parameters = try functionSignature.parameters.enumerated().map { idx, param in
-        let parameterName = param.parameterName ?? "arg\(idx))"
+        let parameterName = param.parameterName ?? "arg\(idx)"
         return try translateParameter(swiftType: param.type, parameterName: parameterName, methodName: methodName, parentName: parentName)
       }
 

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift

@@ -102,6 +102,11 @@ extension JNISwift2JavaGenerator {
       printer.println()
     }
 
+    for enumCase in type.cases {
+      printSwiftFunctionThunk(&printer, enumCase.caseFunction)
+      printer.println()
+    }
+
     for method in type.methods {
       printSwiftFunctionThunk(&printer, method)
       printer.println()
@@ -190,6 +195,18 @@ extension JNISwift2JavaGenerator {
       .joined(separator: ", ")
       result = "\(tryClause)\(callee).\(decl.name)(\(downcallArguments))"
 
+    case .enumCase:
+      let downcallArguments = zip(
+        decl.functionSignature.parameters,
+        arguments
+      ).map { originalParam, argument in
+        let label = originalParam.argumentLabel.map { "\($0): " } ?? ""
+        return "\(label)\(argument)"
+      }
+
+      let associatedValues = !downcallArguments.isEmpty ? "(\(downcallArguments.joined(separator: ", ")))" : ""
+      result = "\(callee).\(decl.name)\(associatedValues)"
+
     case .getter:
       result = "\(tryClause)\(callee).\(decl.name)"
 

Sources/JExtractSwiftLib/Swift2JavaVisitor.swift

@@ -134,6 +134,11 @@ final class Swift2JavaVisitor {
   }
 
   func visit(enumCaseDecl node: EnumCaseDeclSyntax, in typeContext: ImportedNominalType?) {
+    guard let typeContext else {
+      self.log.info("Enum case must be within a current type; \(node)")
+      return
+    }
+
     do {
       for caseElement in node.elements {
         self.log.debug("Import case \(caseElement.name) of enum \(node.qualifiedNameForDebug)")
@@ -142,12 +147,27 @@ final class Swift2JavaVisitor {
           try SwiftEnumCaseParameter($0, lookupContext: translator.lookupContext)
         }
 
-        let imported = ImportedEnumCase(
+        let signature = try SwiftFunctionSignature(
+          caseElement,
+          enclosingType: typeContext.swiftType,
+          lookupContext: translator.lookupContext
+        )
+
+        let caseFunction = ImportedFunc(
+          module: translator.swiftModuleName,
+          swiftDecl: node,
+          name: caseElement.name.text,
+          apiKind: .enumCase,
+          functionSignature: signature
+        )
+
+        let importedCase = ImportedEnumCase(
           name: caseElement.name.text,
-          parameters: parameters ?? []
+          parameters: parameters ?? [],
+          caseFunction: caseFunction
         )
 
-        typeContext?.cases.append(imported)
+        typeContext.cases.append(importedCase)
       }
     } catch {
       self.log.debug("Failed to import: \(node.qualifiedNameForDebug); \(error)")