synthesize RawRepresentable

Author: madsodgaard

Samples/JExtractJNISampleApp/Sources/MySwiftLibrary/Alignment.swift

@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+public enum Alignment: String {
+  case horizontal
+  case vertical
+}

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

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class AlignmentTest {
+    @Test
+    void rawValue() {
+        try (var arena = new ConfinedSwiftMemorySession()) {
+            Optional<Alignment> invalid = Alignment.init("invalid", arena);
+            assertFalse(invalid.isPresent());
+
+            Optional<Alignment> horizontal = Alignment.init("horizontal", arena);
+            assertTrue(horizontal.isPresent());
+            assertEquals("horizontal", horizontal.get().getRawValue());
+
+            Optional<Alignment> vertical = Alignment.init("vertical", arena);
+            assertTrue(vertical.isPresent());
+            assertEquals("vertical", vertical.get().getRawValue());
+        }
+    }
+}

Sources/JExtractSwiftLib/Swift2JavaVisitor.swift

@@ -46,7 +46,7 @@ final class Swift2JavaVisitor {
     case .structDecl(let node):
       self.visit(nominalDecl: node, in: parent)
     case .enumDecl(let node):
-      self.visit(nominalDecl: node, in: parent)
+      self.visit(enumDecl: node, in: parent)
     case .protocolDecl(let node):
       self.visit(nominalDecl: node, in: parent)
     case .extensionDecl(let node):
@@ -85,6 +85,12 @@ final class Swift2JavaVisitor {
     }
   }
 
+  func visit(enumDecl node: EnumDeclSyntax, in parent: ImportedNominalType?) {
+    self.visit(nominalDecl: node, in: parent)
+
+    self.synthesizeRawRepresentableConformance(enumDecl: node, in: parent)
+  }
+
   func visit(extensionDecl node: ExtensionDeclSyntax, in parent: ImportedNominalType?) {
     guard parent != nil else {
       // 'extension' in a nominal type is invalid. Ignore
@@ -256,6 +262,32 @@ final class Swift2JavaVisitor {
 
     typeContext.initializers.append(imported)
   }
+
+  private func synthesizeRawRepresentableConformance(enumDecl node: EnumDeclSyntax, in parent: ImportedNominalType?) {
+    guard let imported = translator.importedNominalType(node, parent: parent) else {
+      return
+    }
+
+    if let firstInheritanceType = imported.swiftNominal.firstInheritanceType,
+      let inheritanceType = try? SwiftType(
+        firstInheritanceType,
+        lookupContext: translator.lookupContext
+      ),
+      inheritanceType.isRawTypeCompatible
+    {
+      if !imported.variables.contains(where: { $0.name == "rawValue" && $0.functionSignature.result.type != inheritanceType }) {
+        let decl: DeclSyntax = "public var rawValue: \(raw: inheritanceType.description) { get }"
+        self.visit(decl: decl, in: imported)
+      }
+
+      imported.variables.first?.signatureString
+
+      if !imported.initializers.contains(where: { $0.functionSignature.parameters.count == 1 && $0.functionSignature.parameters.first?.parameterName == "rawValue" && $0.functionSignature.parameters.first?.type == inheritanceType }) {
+        let decl: DeclSyntax = "public init?(rawValue: \(raw: inheritanceType))"
+        self.visit(decl: decl, in: imported)
+      }
+    }
+  }
 }
 
 extension DeclSyntaxProtocol where Self: WithModifiersSyntax & WithAttributesSyntax {

Sources/JExtractSwiftLib/SwiftTypes/SwiftNominalTypeDeclaration.swift

@@ -85,6 +85,14 @@ package class SwiftNominalTypeDeclaration: SwiftTypeDeclaration {
     super.init(moduleName: moduleName, name: node.name.text)
   }
 
+  lazy var firstInheritanceType: TypeSyntax? = {
+    guard let firstInheritanceType = self.syntax?.inheritanceClause?.inheritedTypes.first else {
+      return nil
+    }
+
+    return firstInheritanceType.type
+  }()
+
   /// Returns true if this type conforms to `Sendable` and therefore is "threadsafe".
   lazy var isSendable: Bool = {
     // Check if Sendable is in the inheritance list

Sources/JExtractSwiftLib/SwiftTypes/SwiftType.swift

@@ -103,6 +103,19 @@ enum SwiftType: Equatable {
     default: false
     }
   }
+
+  var isRawTypeCompatible: Bool {
+    switch self {
+    case .nominal(let nominal):
+      switch nominal.nominalTypeDecl.knownTypeKind {
+      case .int, .uint, .int8, .uint8, .int16, .uint16, .int32, .uint32, .int64, .uint64, .float, .double, .string:
+        true
+      default:
+        false
+      }
+    default: false
+    }
+  }
 }
 
 extension SwiftType: CustomStringConvertible {