Finish the migration from ImportedTypeName over to TranslatedType

TranslatedType captures more information about how the type is
represented in Swift, Java, and the intermediate stages in between.

Author: DougGregor

Sources/JExtractSwift/ImportedDecls.swift

@@ -15,16 +15,12 @@ import Foundation
 import JavaTypes
 import SwiftSyntax
 
-protocol ImportedDecl: Hashable {
+protocol ImportedDecl {
 
 }
 
 public typealias JavaPackage = String
 
-public struct ImportedProtocol: ImportedDecl {
-  public var identifier: String
-}
-
 /// 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 {
@@ -43,9 +39,12 @@ public struct ImportedNominalType: ImportedDecl {
     self.kind = kind
   }
 
-  var importedTypeName: ImportedTypeName {
-    ImportedTypeName(
-      swiftTypeName: swiftTypeName,
+  var translatedType: TranslatedType {
+    TranslatedType(
+      cCompatibleConvention: .direct,
+      originalSwiftType: "\(raw: swiftTypeName)",
+      cCompatibleSwiftType: "\(raw: swiftTypeName)",
+      cCompatibleJavaMemoryLayout: .heapObject,
       javaType: javaType
     )
   }
@@ -58,7 +57,7 @@ public enum NominalTypeKind {
   case `struct`
 }
 
-public struct ImportedParam: Hashable {
+public struct ImportedParam {
   let param: FunctionParameterSyntax
 
   var firstName: String? {
@@ -89,7 +88,7 @@ public struct ImportedParam: Hashable {
   }
 
   // The mapped-to Java type of the above Java type, collections and optionals may be replaced with Java ones etc.
-  var type: ImportedTypeName
+  var type: TranslatedType
 }
 
 extension ImportedParam {
@@ -102,30 +101,6 @@ extension ImportedParam {
   }
 }
 
-public struct ImportedTypeName: Hashable {
-  public var swiftTypeName: String
-
-  public var swiftMangledName: String = ""
-
-  public var javaType: JavaType
-
-  public var isVoid: Bool { javaType == .void }
-
-  public var fullyQualifiedName: String { javaType.description }
-
-  /// Retrieve the Java class name that this type describes, or nil if it
-  /// doesn't represent a class at all.
-  public var javaClassName: String? {
-    javaType.className
-  }
-
-  public init(swiftTypeName: String, javaType: JavaType, swiftMangledName: String? = nil) {
-    self.swiftTypeName = swiftTypeName
-    self.javaType = javaType
-    self.swiftMangledName = swiftMangledName ?? ""
-  }
-}
-
 // TODO: this is used in different contexts and needs a cleanup
 public enum SelfParameterVariant {
   /// Make a method that accepts the raw memory pointer as a MemorySegment
@@ -141,7 +116,7 @@ public struct ImportedFunc: ImportedDecl, CustomStringConvertible {
   /// this will contain that declaration's imported name.
   ///
   /// This is necessary when rendering accessor Java code we need the type that "self" is expecting to have.
-  public var parentName: ImportedTypeName?
+  var parentName: TranslatedType?
   public var hasParent: Bool { parentName != nil }
 
   /// This is a full name such as init(cap:name:).
@@ -166,7 +141,7 @@ public struct ImportedFunc: ImportedDecl, CustomStringConvertible {
     return identifier
   }
 
-  public var returnType: ImportedTypeName
+  public var returnType: TranslatedType
   public var parameters: [ImportedParam]
 
   public func effectiveParameters(selfVariant: SelfParameterVariant?) -> [ImportedParam] {
@@ -185,28 +160,18 @@ public struct ImportedFunc: ImportedDecl, CustomStringConvertible {
         params.append(
           ImportedParam(
             param: selfParam,
-            type: TranslatedType(
-              cCompatibleConvention: .indirect,
-              originalSwiftType: "\(raw: parentName.swiftTypeName)",
-              cCompatibleSwiftType: "UnsafeRawPointer",
-              cCompatibleJavaMemoryLayout: .heapObject,
-              javaType: .javaForeignMemorySegment
-            ).importedTypeName
+            type: parentName
           )
         )
 
       case .memorySegment:
         let selfParam: FunctionParameterSyntax = "self$: $java_lang_foreign_MemorySegment"
+        var parentForSelf = parentName
+        parentForSelf.javaType = .javaForeignMemorySegment
         params.append(
           ImportedParam(
             param: selfParam,
-            type: TranslatedType(
-              cCompatibleConvention: .indirect,
-              originalSwiftType: "\(raw: parentName.swiftTypeName)",
-              cCompatibleSwiftType: "UnsafeRawPointer",
-              cCompatibleJavaMemoryLayout: .heapObject,
-              javaType: .javaForeignMemorySegment
-            ).importedTypeName
+            type: parentForSelf
           )
         )
 
@@ -230,9 +195,9 @@ public struct ImportedFunc: ImportedDecl, CustomStringConvertible {
   public var isInit: Bool = false
 
   public init(
-    parentName: ImportedTypeName?,
+    parentName: TranslatedType?,
     identifier: String,
-    returnType: ImportedTypeName,
+    returnType: TranslatedType,
     parameters: [ImportedParam]
   ) {
     self.parentName = parentName

Sources/JExtractSwift/Swift2JavaTranslator+MemoryLayouts.swift

@@ -16,8 +16,6 @@ import SwiftBasicFormat
 import SwiftParser
 import SwiftSyntax
 
-let SWIFT_POINTER = "SWIFT_POINTER"
-
 extension Swift2JavaTranslator {
   public func javaMemoryLayoutDescriptors(
     forParametersOf decl: ImportedFunc,
@@ -31,61 +29,9 @@ extension Swift2JavaTranslator {
     //      decl.isInit ? nil : .wrapper
 
     for param in decl.effectiveParameters(selfVariant: selfVariant) {
-      if let paramLayout = javaMemoryLayoutDescriptor(param.type) {
-        layouts.append(paramLayout)
-      }
+      layouts.append(param.type.foreignValueLayout)
     }
 
     return layouts
   }
-
-  // This may reach for another types $layout I think
-  public func javaMemoryLayoutDescriptor(_ ty: ImportedTypeName) -> ForeignValueLayout? {
-    switch ty.swiftTypeName {
-    case "Bool":
-      return .SwiftBool
-    case "Int":
-      return .SwiftInt
-    case "Int32":
-      return .SwiftInt32
-    case "Int64":
-      return .SwiftInt64
-    case "Float":
-      return .SwiftFloat
-    case "Double":
-      return .SwiftDouble
-    case "Void":
-      return nil
-    case "Never":
-      return nil
-    case "Swift.UnsafePointer<Swift.UInt8>":
-      return .SwiftPointer
-    default:
-      break
-    }
-
-    // not great?
-    if ty.swiftTypeName == "Self.self" {
-      return .SwiftPointer
-    }
-
-    // not great?
-    if ty.swiftTypeName == "(any Any.Type)?" {
-      return .SwiftPointer
-    }
-
-    if ty.swiftTypeName == "() -> ()" {
-      return .SwiftPointer
-    }
-
-    // TODO: Java has OptionalLong, OptionalInt, OptionalDouble types.
-    // if ty.swiftTypeName.hasSuffix("?") {
-    // if ty.swiftTypeName == "Int?" {
-    //   return JavaOptionalLong
-    // } else ..
-    // }
-
-    // Last fallback is to try to get the type's $layout()
-    return ForeignValueLayout(inlineComment: ty.swiftTypeName, customType: ty.fullyQualifiedName)
-  }
 }

Sources/JExtractSwift/Swift2JavaTranslator+Printing.swift

@@ -421,15 +421,15 @@ extension Swift2JavaTranslator {
        * \(decl.swiftDeclRaw ?? "")
        * }
        */
-      public static \(parentName.javaClassName!) init(\(renderJavaParamDecls(decl, selfVariant: .none))) {
+      public static \(parentName.javaType) init(\(renderJavaParamDecls(decl, selfVariant: .none))) {
         var mh$ = \(descClassIdentifier).HANDLE;
         try {
             if (TRACE_DOWNCALLS) {
               traceDowncall(\(renderForwardParams(decl, selfVariant: nil)));
             }
 
             var self = (MemorySegment) mh$.invokeExact(\(renderForwardParams(decl, selfVariant: nil)), TYPE_METADATA);
-            return new \(parentName.javaClassName!)(self);
+            return new \(parentName.javaType)(self);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
@@ -524,10 +524,10 @@ extension Swift2JavaTranslator {
     decl: ImportedFunc,
     selfVariant: SelfParameterVariant?
   ) {
-    let returnTy = decl.returnType.fullyQualifiedName
+    let returnTy = decl.returnType.javaType
 
     let maybeReturnCast: String
-    if decl.returnType.isVoid {
+    if decl.returnType.javaType == .void {
       maybeReturnCast = ""  // nothing to return or cast to
     } else {
       maybeReturnCast = "return (\(returnTy))"
@@ -601,7 +601,7 @@ extension Swift2JavaTranslator {
     }
 
     for p in decl.effectiveParameters(selfVariant: selfVariant) {
-      let param = "\(p.type.fullyQualifiedName) \(p.effectiveName ?? nextUniqueParamName())"
+      let param = "\(p.type.javaType.description) \(p.effectiveName ?? nextUniqueParamName())"
       ps.append(param)
     }
 
@@ -641,7 +641,7 @@ extension Swift2JavaTranslator {
       selfVariant: .pointer
     )
 
-    if decl.returnType.isVoid {
+    if decl.returnType.javaType == .void {
       printer.print("FunctionDescriptor.ofVoid(");
       printer.indent()
     } else {
@@ -655,10 +655,9 @@ extension Swift2JavaTranslator {
         // when initializing, we return a pointer to the newly created object
         printer.print("/* -> */\(ForeignValueLayout.SwiftPointer)", .parameterNewlineSeparator(returnTyIsLastTy))
       } else {
-        if var returnDesc = javaMemoryLayoutDescriptor(decl.returnType) {
-          returnDesc.inlineComment = " -> "
-          printer.print(returnDesc, .parameterNewlineSeparator(returnTyIsLastTy))
-        }
+        var returnDesc = decl.returnType.foreignValueLayout
+        returnDesc.inlineComment = " -> "
+        printer.print(returnDesc, .parameterNewlineSeparator(returnTyIsLastTy))
       }
     }
 

Sources/JExtractSwift/Swift2JavaVisitor.swift

@@ -120,18 +120,18 @@ final class Swift2JavaVisitor: SyntaxVisitor {
     }
 
     let params: [ImportedParam]
-    let javaResultType: ImportedTypeName
+    let javaResultType: TranslatedType
     do {
       params = try node.signature.parameterClause.parameters.map { param in
         // TODO: more robust parameter handling
         // TODO: More robust type handling
         return ImportedParam(
           param: param,
-          type: try mapTypeToJava(name: param.type)
+          type: try cCompatibleType(for: param.type)
         )
       }
 
-      javaResultType = try mapTypeToJava(name: returnTy)
+      javaResultType = try cCompatibleType(for: returnTy)
     } catch {
       self.log.info("Unable to import function \(node.name) - \(error)")
       return .skipChildren
@@ -147,7 +147,7 @@ final class Swift2JavaVisitor: SyntaxVisitor {
     let fullName = "\(node.name.text)(\(argumentLabelsStr))"
 
     var funcDecl = ImportedFunc(
-      parentName: currentTypeName.map { translator.importedTypes[$0] }??.importedTypeName,
+      parentName: currentTypeName.map { translator.importedTypes[$0] }??.translatedType,
       identifier: fullName,
       returnType: javaResultType,
       parameters: params
@@ -186,7 +186,7 @@ final class Swift2JavaVisitor: SyntaxVisitor {
         // TODO: More robust type handling
         return ImportedParam(
           param: param,
-          type: try mapTypeToJava(name: param.type)
+          type: try cCompatibleType(for: param.type)
         )
       }
     } catch {
@@ -198,9 +198,9 @@ final class Swift2JavaVisitor: SyntaxVisitor {
       "init(\(params.compactMap { $0.effectiveName ?? "_" }.joined(separator: ":")))"
 
     var funcDecl = ImportedFunc(
-      parentName: currentType.importedTypeName,
+      parentName: currentType.translatedType,
       identifier: initIdentifier,
-      returnType: currentType.importedTypeName,
+      returnType: currentType.translatedType,
       parameters: params
     )
     funcDecl.isInit = true
@@ -254,13 +254,6 @@ extension FunctionDeclSyntax {
   }
 }
 
-extension Swift2JavaVisitor {
-  // TODO: this is more more complicated, we need to know our package and imports etc
-  func mapTypeToJava(name swiftType: TypeSyntax) throws -> ImportedTypeName {
-    return try cCompatibleType(for: swiftType).importedTypeName
-  }
-}
-
 private let mangledNameCommentPrefix = "MANGLED NAME: "
 
 extension SyntaxProtocol {

Sources/JExtractSwift/TranslatedType.swift

@@ -207,7 +207,7 @@ enum ParameterConvention {
   case indirect
 }
 
-struct TranslatedType {
+public struct TranslatedType {
   /// How a parameter of this type will be passed through C functions.
   var cCompatibleConvention: ParameterConvention
 
@@ -224,14 +224,10 @@ struct TranslatedType {
 
   /// The Java type that is used to present these values in Java.
   var javaType: JavaType
-}
 
-extension TranslatedType {
-  var importedTypeName: ImportedTypeName {
-    ImportedTypeName(
-      swiftTypeName: originalSwiftType.trimmedDescription,
-      javaType: javaType
-    )
+  /// Produce a Swift type name to reference this type.
+  var swiftTypeName: String {
+    originalSwiftType.trimmedDescription
   }
 }