jextract import optional types

Sources/JExtractSwift/JavaTypes.swift

@@ -25,3 +25,51 @@ extension JavaType {
     .class(package: "java.lang", name: "Runnable")
   }
 }
+
+// ==== ------------------------------------------------------------------------
+// Optionals
+
+extension JavaType {
+
+  static var javaUtilOptionalInt: JavaType {
+    .class(package: "java.util", name: "OptionalInt")
+  }
+
+  static var javaUtilOptionalLong: JavaType {
+    .class(package: "java.util", name: "OptionalLong")
+  }
+
+  static var javaUtilOptionalDouble: JavaType {
+    .class(package: "java.util", name: "OptionalDouble")
+  }
+
+  // FIXME: general generics?
+  static func javaUtilOptionalT(_ javaType: JavaType) -> JavaType {
+    if let className = javaType.className {
+      return .class(package: "java.util", name: "Optional<\(className)>")
+    }
+
+    if javaType.isPrimitive {
+      switch javaType {
+      case .int, .long:
+        return .javaUtilOptionalLong
+      case .float, .double:
+        return .javaUtilOptionalDouble
+      case .boolean:
+        return .class(package: "java.util", name: "Optional<Boolean>")
+      case .byte:
+        return .class(package: "java.util", name: "Optional<Byte>")
+      case .char:
+        return .class(package: "java.util", name: "Optional<Character>")
+      case .short:
+        return .class(package: "java.util", name: "Optional<Short>")
+      case .void:
+        return .class(package: "java.util", name: "Optional<Void>")
+      default:
+        fatalError("Impossible type to map to Optional: \(javaType)")
+      }
+    }
+
+    fatalError("Impossible type to map to Optional: \(javaType)")
+  }
+}

Sources/JExtractSwift/Swift2JavaVisitor.swift

@@ -100,6 +100,7 @@ final class Swift2JavaVisitor: SyntaxVisitor {
       }
 
       javaResultType = try cCompatibleType(for: returnTy)
+      log.trace("Mapped return type type: \(returnTy) -> \(javaResultType)")
     } catch {
       self.log.info("Unable to import function \(node.name) - \(error)")
       return .skipChildren

Sources/JExtractSwift/TranslatedType.swift

@@ -23,10 +23,30 @@ extension Swift2JavaVisitor {
     case .arrayType, .attributedType, .classRestrictionType, .compositionType,
         .dictionaryType, .implicitlyUnwrappedOptionalType, .metatypeType,
         .missingType, .namedOpaqueReturnType,
-        .optionalType, .packElementType, .packExpansionType, .someOrAnyType,
+        .packElementType, .packExpansionType, .someOrAnyType,
         .suppressedType, .tupleType:
       throw TypeTranslationError.unimplementedType(type)
 
+    case .optionalType(let optionalType):
+      if optionalType.wrappedType.trimmedDescription == "Int" {
+        return TranslatedType(
+          cCompatibleConvention: .direct,
+          originalSwiftType: optionalType.wrappedType, // FIXME: just optionalType?
+          cCompatibleSwiftType: "OptionalLong",
+          cCompatibleJavaMemoryLayout: .heapObject,
+          javaType: .javaUtilOptionalLong
+        )
+      } else if let translatedWrappedType = try? cCompatibleType(for: optionalType.wrappedType) {
+        return TranslatedType(
+          cCompatibleConvention: .direct,
+          originalSwiftType: optionalType.wrappedType, // FIXME: just optionalType?
+          cCompatibleSwiftType: "Optional<TODO>",
+          cCompatibleJavaMemoryLayout: .heapObject,
+          javaType: .javaUtilOptionalT(translatedWrappedType.javaType)
+        )
+      } else {
+        throw TypeTranslationError.unimplementedType(type)
+      }
     case .functionType(let functionType):
       // FIXME: Temporary hack to keep existing code paths working.
       if functionType.trimmedDescription == "() -> ()" {

Tests/JExtractSwiftTests/OptionalImportTests.swift

@@ -0,0 +1,129 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+import JExtractSwift
+import Testing
+
+final class OptionalImportTests {
+  let class_interfaceFile =
+    """
+    // swift-interface-format-version: 1.0
+    // swift-compiler-version: Apple Swift version 6.0 effective-5.10 (swiftlang-6.0.0.7.6 clang-1600.0.24.1)
+    // swift-module-flags: -target arm64-apple-macosx15.0 -enable-objc-interop -enable-library-evolution -module-name MySwiftLibrary
+    import Darwin.C
+    import Darwin
+    import Swift
+    import _Concurrency
+    import _StringProcessing
+    import _SwiftConcurrencyShims
+
+    // MANGLED NAME: $fake
+    public func globalGetStringOptional() -> String?
+
+    // MANGLED NAME: $fake
+    public func globalGetIntOptional() -> Int?
+
+    // FIXME: Hack to allow us to translate "String", even though it's not
+    // actually available
+    // MANGLED NAME: $ss
+    public class String {
+    }
+    """
+
+  @Test("Import: public func globalGetIntOptional() -> Int?")
+  func globalGetIntOptional() throws {
+    let st = Swift2JavaTranslator(
+      javaPackage: "com.example.swift",
+      swiftModuleName: "__FakeModule"
+    )
+    st.log.logLevel = .warning
+
+    try st.analyze(swiftInterfacePath: "/fake/Fake.swiftinterface", text: class_interfaceFile)
+
+    let funcDecl = st.importedGlobalFuncs.first {
+      $0.baseIdentifier == "globalGetIntOptional"
+    }!
+
+    let output = CodePrinter.toString { printer in
+      st.printFuncDowncallMethod(&printer, decl: funcDecl, selfVariant: nil)
+    }
+
+    assertOutput(
+      output,
+      expected:
+      """
+      /**
+       * Downcall to Swift:
+       * {@snippet lang=swift :
+       * public func globalGetIntOptional() -> Int?
+       * }
+       */
+      public static java.util.OptionalLong globalGetIntOptional() {
+          var mh$ = globalGetIntOptional.HANDLE;
+          try {
+              if (TRACE_DOWNCALLS) {
+                  traceDowncall();
+              }
+              return (java.util.OptionalLong) mh$.invokeExact();
+          } catch (Throwable ex$) {
+              throw new AssertionError("should not reach here", ex$);
+          }
+      }
+      """
+    )
+  }
+
+  @Test("Import: public func globalGetStringOptional() -> String?")
+  func globalGetStringOptional() throws {
+    let st = Swift2JavaTranslator(
+      javaPackage: "com.example.swift",
+      swiftModuleName: "__FakeModule"
+    )
+    st.log.logLevel = .warning
+
+    try st.analyze(swiftInterfacePath: "/fake/Fake.swiftinterface", text: class_interfaceFile)
+
+    let funcDecl = st.importedGlobalFuncs.first {
+      $0.baseIdentifier == "globalGetStringOptional"
+    }!
+
+    let output = CodePrinter.toString { printer in
+      st.printFuncDowncallMethod(&printer, decl: funcDecl, selfVariant: nil)
+    }
+
+    assertOutput(
+      output,
+      expected:
+      """
+      /**
+       * Downcall to Swift:
+       * {@snippet lang=swift :
+       * public func globalGetStringOptional() -> String?
+       * }
+       */
+      public static java.util.Optional<String> globalGetStringOptional() {
+          var mh$ = globalGetStringOptional.HANDLE;
+          try {
+              if (TRACE_DOWNCALLS) {
+                  traceDowncall();
+              }
+              return (java.util.Optional<String>) mh$.invokeExact();
+          } catch (Throwable ex$) {
+              throw new AssertionError("should not reach here", ex$);
+          }
+      }
+      """
+    )
+  }
+}