Move more type handling over to TranslatedType so we can centralize there

Author: DougGregor

Sources/JExtractSwift/ImportedDecls.swift

@@ -28,16 +28,27 @@ public struct ImportedProtocol: ImportedDecl {
 /// Describes a Swift nominal type (e.g., a class, struct, enum) that has been
 /// imported and is being translated into Java.
 public struct ImportedNominalType: ImportedDecl {
-  public var name: ImportedTypeName
+  public let swiftTypeName: String
+  public let javaType: JavaType
+  public var swiftMangledName: String?
   public var kind: NominalTypeKind
 
   public var initializers: [ImportedFunc] = []
   public var methods: [ImportedFunc] = []
 
-  public init(name: ImportedTypeName, kind: NominalTypeKind) {
-    self.name = name
+  public init(swiftTypeName: String, javaType: JavaType, swiftMangledName: String? = nil, kind: NominalTypeKind) {
+    self.swiftTypeName = swiftTypeName
+    self.javaType = javaType
+    self.swiftMangledName = swiftMangledName
     self.kind = kind
   }
+
+  var importedTypeName: ImportedTypeName {
+    ImportedTypeName(
+      swiftTypeName: swiftTypeName,
+      javaType: javaType
+    )
+  }
 }
 
 public enum NominalTypeKind {
@@ -172,13 +183,31 @@ public struct ImportedFunc: ImportedDecl, CustomStringConvertible {
       case .pointer:
         let selfParam: FunctionParameterSyntax = "self$: $swift_pointer"
         params.append(
-          ImportedParam(param: selfParam, type: java_lang_foreign_MemorySegment(swiftTypeName: "Self.self"))
+          ImportedParam(
+            param: selfParam,
+            type: TranslatedType(
+              cCompatibleConvention: .indirect,
+              originalSwiftType: "\(raw: parentName.swiftTypeName)",
+              cCompatibleSwiftType: "UnsafeRawPointer",
+              cCompatibleJavaMemoryLayout: .memorySegment,
+              javaType: .javaForeignMemorySegment
+            ).importedTypeName
+          )
         )
 
       case .memorySegment:
         let selfParam: FunctionParameterSyntax = "self$: $java_lang_foreign_MemorySegment"
         params.append(
-          ImportedParam(param: selfParam, type: java_lang_foreign_MemorySegment(swiftTypeName: ""))
+          ImportedParam(
+            param: selfParam,
+            type: TranslatedType(
+              cCompatibleConvention: .indirect,
+              originalSwiftType: "\(raw: parentName.swiftTypeName)",
+              cCompatibleSwiftType: "UnsafeRawPointer",
+              cCompatibleJavaMemoryLayout: .memorySegment,
+              javaType: .javaForeignMemorySegment
+            ).importedTypeName
+          )
         )
 
       case .wrapper:

Sources/JExtractSwift/JavaTypes.swift

@@ -13,13 +13,6 @@
 
 import JavaTypes
 
-func java_lang_foreign_MemorySegment(swiftTypeName: String) -> ImportedTypeName {
-  ImportedTypeName(
-    swiftTypeName: swiftTypeName,
-    javaType: .javaForeignMemorySegment
-  )
-}
-
 extension JavaType {
   /// The description of the type java.lang.foreign.MemorySegment.
   static var javaForeignMemorySegment: JavaType {

Sources/JExtractSwift/Swift2JavaTranslator+Printing.swift

@@ -28,7 +28,7 @@ extension Swift2JavaTranslator {
     var printer = CodePrinter()
 
     for (_, ty) in importedTypes.sorted(by: { (lhs, rhs) in lhs.key < rhs.key }) {
-      let filename = "\(ty.name.javaClassName!).java"
+      let filename = "\(ty.javaType).java"
       log.info("Printing contents: \(filename)")
       printImportedClass(&printer, ty)
 
@@ -116,7 +116,7 @@ extension Swift2JavaTranslator {
       printer.print(
         """
         // FIXME: this detecting is somewhat off
-        public static final String TYPE_METADATA_NAME = "\(decl.name.swiftMangledName)";
+        public static final String TYPE_METADATA_NAME = "\(decl.swiftMangledName!)";
         static final MemorySegment TYPE_METADATA = SwiftKit.getTypeByMangledNameInEnvironment(TYPE_METADATA_NAME);
         """
       )
@@ -165,7 +165,7 @@ extension Swift2JavaTranslator {
   }
 
   public func printClass(_ printer: inout CodePrinter, _ decl: ImportedNominalType, body: (inout CodePrinter) -> Void) {
-    printer.printTypeDecl("public final class \(decl.name.javaClassName!)") { printer in
+    printer.printTypeDecl("public final class \(decl.javaType)") { printer in
       // ==== Storage of the class
       // FIXME: implement the self storage for the memory address and accessors
       printClassSelfProperty(&printer, decl)
@@ -274,7 +274,7 @@ extension Swift2JavaTranslator {
     printer.print(
       """
       /** Instances are created using static {@code init} methods rather than through the constructor directly. */
-      private \(decl.name.javaClassName!)(MemorySegment selfMemorySegment) {
+      private \(decl.javaType)(MemorySegment selfMemorySegment) {
         this.selfMemorySegment = selfMemorySegment;
       }
       """
@@ -307,7 +307,7 @@ extension Swift2JavaTranslator {
         // SWIFT_INT.withName("heapObject"),
         // ...
         // SWIFT_INT.withName("cap")
-      ).withName("\(decl.name.javaClassName!)"); // TODO: is the name right?
+      ).withName("\(decl.javaType)"); // TODO: is the name right?
 
       /**
        * When other types refer to this type, they refer to by a pointer,

Sources/JExtractSwift/Swift2JavaTranslator.swift

@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 import Foundation
+import JavaTypes
 import SwiftBasicFormat
 import SwiftParser
 import SwiftSyntax
@@ -56,6 +57,15 @@ public final class Swift2JavaTranslator {
 // MARK: Analysis
 
 extension Swift2JavaTranslator {
+  /// The primitive Java type to use for Swift's Int type, which follows the
+  /// size of a pointer.
+  ///
+  /// FIXME: Consider whether to extract this information from the Swift
+  /// interface file, so that it would be 'int' for 32-bit targets or 'long' for
+  /// 64-bit targets but make the Java code different for the two, vs. adding
+  /// a checked truncation operation at the Java/Swift board.
+  var javaPrimitiveForSwiftInt: JavaType { .long }
+
   public func analyze(
     swiftInterfacePath: String,
     text: String? = nil
@@ -126,11 +136,11 @@ extension Swift2JavaTranslator {
 
     importedTypes = Dictionary(uniqueKeysWithValues: try await importedTypes._mapAsync { (tyName, tyDecl) in
       var tyDecl = tyDecl
-      log.info("Mapping type: \(tyDecl.name)")
+      log.info("Mapping type: \(tyDecl.swiftTypeName)")
 
       tyDecl = try await dylib.fillInTypeMangledName(tyDecl)
 
-      log.info("Mapping members of: \(tyDecl.name)")
+      log.info("Mapping members of: \(tyDecl.swiftTypeName)")
       tyDecl.initializers = try await tyDecl.initializers._mapAsync { initDecl in
         dylib.log.logLevel = .trace
 

Sources/JExtractSwift/Swift2JavaVisitor.swift

@@ -57,14 +57,12 @@ final class Swift2JavaVisitor: SyntaxVisitor {
     }
 
     let importedNominal = ImportedNominalType(
-      name: ImportedTypeName(
-        swiftTypeName: fullName,
-        javaType: .class(
-          package: targetJavaPackage,
-          name: fullName
-        ),
-        swiftMangledName: nominal.mangledNameFromComment
+      swiftTypeName: fullName,
+      javaType: .class(
+        package: targetJavaPackage,
+        name: fullName
       ),
+      swiftMangledName: nominal.mangledNameFromComment,
       kind: kind
     )
 
@@ -77,7 +75,7 @@ final class Swift2JavaVisitor: SyntaxVisitor {
       return .skipChildren
     }
 
-    currentTypeName = importedNominalType.name.swiftTypeName
+    currentTypeName = importedNominalType.swiftTypeName
     return .visitChildren
   }
 
@@ -96,7 +94,7 @@ final class Swift2JavaVisitor: SyntaxVisitor {
       return .skipChildren
     }
 
-    currentTypeName = importedNominalType.name.swiftTypeName
+    currentTypeName = importedNominalType.swiftTypeName
     return .visitChildren
   }
 
@@ -149,7 +147,7 @@ final class Swift2JavaVisitor: SyntaxVisitor {
     let fullName = "\(node.name.text)(\(argumentLabelsStr))"
 
     var funcDecl = ImportedFunc(
-      parentName: currentTypeName.map { translator.importedTypes[$0] }??.name,
+      parentName: currentTypeName.map { translator.importedTypes[$0] }??.importedTypeName,
       identifier: fullName,
       returnType: javaResultType,
       parameters: params
@@ -180,7 +178,7 @@ final class Swift2JavaVisitor: SyntaxVisitor {
       return .skipChildren
     }
 
-    self.log.info("Import initializer: \(node.kind) \(currentType.name.javaType.description)")
+    self.log.info("Import initializer: \(node.kind) \(currentType.javaType.description)")
     let params: [ImportedParam]
     do {
       params = try node.signature.parameterClause.parameters.map { param in
@@ -200,9 +198,9 @@ final class Swift2JavaVisitor: SyntaxVisitor {
       "init(\(params.compactMap { $0.effectiveName ?? "_" }.joined(separator: ":")))"
 
     var funcDecl = ImportedFunc(
-      parentName: currentType.name,
+      parentName: currentType.importedTypeName,
       identifier: initIdentifier,
-      returnType: currentType.name,
+      returnType: currentType.importedTypeName,
       parameters: params
     )
     funcDecl.isInit = true
@@ -213,7 +211,7 @@ final class Swift2JavaVisitor: SyntaxVisitor {
       funcDecl.swiftMangledName = mangledName
     }
 
-    log.info("Record initializer method in \(currentType.name.javaType.description): \(funcDecl.identifier)")
+    log.info("Record initializer method in \(currentType.javaType.description): \(funcDecl.identifier)")
     translator.importedTypes[currentTypeName]!.initializers.append(funcDecl)
 
     return .skipChildren

Sources/JExtractSwift/SwiftDylib.swift

@@ -33,19 +33,19 @@ package struct SwiftDylib {  // FIXME: remove this entire utility; replace with
 
   package func fillInTypeMangledName(_ decl: ImportedNominalType) async throws -> ImportedNominalType {
     // TODO: this is hacky, not precise at all and will be removed entirely
-    guard decl.name.swiftMangledName.isEmpty else {
+    guard decl.swiftMangledName == nil else {
       // it was already processed
       return decl
     }
 
     var decl = decl
     let names = try await nmSymbolNames(grepDemangled: [
-      decl.name.swiftTypeName,
+      decl.swiftTypeName,
       "type metadata for",
     ])
     if let name = names.first {
-      log.trace("Selected mangled name for '\(decl.name.javaType.description)': \(name)")
-      decl.name.swiftMangledName = name.mangledName
+      log.trace("Selected mangled name for '\(decl.javaType.description)': \(name)")
+      decl.swiftMangledName = name.mangledName
     }
 
     return decl

Sources/JExtractSwift/TranslatedType.swift

@@ -102,6 +102,19 @@ extension Swift2JavaVisitor {
       )
     }
 
+    // If this is the Swift "Int" type, it's primitive in Java but might
+    // map to either "int" or "long" depending whether the platform is
+    // 32-bit or 64-bit.
+    if parent == nil, name == "Int" {
+      return TranslatedType(
+        cCompatibleConvention: .direct,
+        originalSwiftType: "\(raw: name)",
+        cCompatibleSwiftType: "Swift.\(raw: name)",
+        cCompatibleJavaMemoryLayout: .int,
+        javaType: translator.javaPrimitiveForSwiftInt
+      )
+    }
+
     // Identify the various pointer types from the standard library.
     if let (requiresArgument, _, _) = name.isNameOfSwiftPointerType {
       // Dig out the pointee type if needed.
@@ -220,10 +233,16 @@ extension TranslatedType {
       javaType: javaType
     )
   }
-
 }
+
 enum CCompatibleJavaMemoryLayout {
+  /// A primitive Java type.
   case primitive(JavaType)
+
+  /// The Swift "Int" type, which may be either a Java int (32-bit platforms) or
+  /// Java long (64-bit platforms).
+  case int
+
   case memorySegment
 }
 

Sources/JavaTypes/JavaType+SwiftNames.swift

@@ -63,10 +63,6 @@ extension JavaType {
     case "Float": self = .float
     case "Double": self = .double
     case "Void": self = .void
-
-    /// NOTE: This is only correct for 64-bit platforms.
-    case "Int": self = .long
-
     default: return nil
     }
   }