Go through nominal type resolution when translating types.

When determining how to translate a Swift nominal type for Java, go
through the nominal lookup mechanism so we will (1) only find types
that we actually know about, rather than guessing, and (2) lazily form
the imported type record so we can handle seeing types out-of-order.

Author: DougGregor

Sources/JExtractSwift/ImportedDecls.swift

@@ -43,7 +43,7 @@ public struct ImportedNominalType: ImportedDecl {
     TranslatedType(
       cCompatibleConvention: .direct,
       originalSwiftType: "\(raw: swiftTypeName)",
-      cCompatibleSwiftType: "\(raw: swiftTypeName)",
+      cCompatibleSwiftType: "UnsafeRawPointer",
       cCompatibleJavaMemoryLayout: .heapObject,
       javaType: javaType
     )

Sources/JExtractSwift/Swift2JavaTranslator.swift

@@ -182,6 +182,51 @@ extension Swift2JavaTranslator {
 
 }
 
+// ==== ----------------------------------------------------------------------------------------------------------------
+// MARK: Type translation
+extension Swift2JavaTranslator {
+  /// Try to resolve the given nominal type node into its imported
+  /// representation.
+  func importedNominalType(
+    _ nominal: some DeclGroupSyntax & NamedDeclSyntax
+  ) -> ImportedNominalType? {
+    if !nominal.shouldImport(log: log) {
+      return nil
+    }
+
+    guard let fullName = nominalResolution.fullyQualifiedName(of: nominal) else {
+      return nil
+    }
+
+    if let alreadyImported = importedTypes[fullName] {
+      return alreadyImported
+    }
+
+    // Determine the nominal type kind.
+    let kind: NominalTypeKind
+    switch Syntax(nominal).as(SyntaxEnum.self) {
+    case .actorDecl:  kind = .actor
+    case .classDecl:  kind = .class
+    case .enumDecl:   kind = .enum
+    case .structDecl: kind = .struct
+    default: return nil
+    }
+
+    let importedNominal = ImportedNominalType(
+      swiftTypeName: fullName,
+      javaType: .class(
+        package: javaPackage,
+        name: fullName
+      ),
+      swiftMangledName: nominal.mangledNameFromComment,
+      kind: kind
+    )
+
+    importedTypes[fullName] = importedNominal
+    return importedNominal
+  }
+}
+
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: Errors
 

Sources/JExtractSwift/Swift2JavaVisitor.swift

@@ -38,40 +38,8 @@ final class Swift2JavaVisitor: SyntaxVisitor {
     super.init(viewMode: .all)
   }
 
-  /// Try to resolve the given nominal type node into its imported
-  /// representation.
-  func resolveNominalType(
-    _ nominal: some DeclGroupSyntax & NamedDeclSyntax,
-    kind: NominalTypeKind
-  ) -> ImportedNominalType? {
-    if !nominal.shouldImport(log: log) {
-      return nil
-    }
-
-    guard let fullName = translator.nominalResolution.fullyQualifiedName(of: nominal) else {
-      return nil
-    }
-
-    if let alreadyImported = translator.importedTypes[fullName] {
-      return alreadyImported
-    }
-
-    let importedNominal = ImportedNominalType(
-      swiftTypeName: fullName,
-      javaType: .class(
-        package: targetJavaPackage,
-        name: fullName
-      ),
-      swiftMangledName: nominal.mangledNameFromComment,
-      kind: kind
-    )
-
-    translator.importedTypes[fullName] = importedNominal
-    return importedNominal
-  }
-
   override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
-    guard let importedNominalType = resolveNominalType(node, kind: .class) else {
+    guard let importedNominalType = translator.importedNominalType(node) else {
       return .skipChildren
     }
 
@@ -90,7 +58,7 @@ final class Swift2JavaVisitor: SyntaxVisitor {
     // Resolve the extended type of the extension as an imported nominal, and
     // recurse if we found it.
     guard let nominal = translator.nominalResolution.extendedType(of: node),
-          let importedNominalType = resolveNominalType(nominal, kind: .class) else {
+          let importedNominalType = translator.importedNominalType(nominal) else {
       return .skipChildren
     }
 

Sources/JExtractSwift/TranslatedType.swift

@@ -116,7 +116,7 @@ extension Swift2JavaVisitor {
     }
 
     // Identify the various pointer types from the standard library.
-    if let (requiresArgument, _, _) = name.isNameOfSwiftPointerType {
+    if let (requiresArgument, _, hasCount) = name.isNameOfSwiftPointerType, !hasCount {
       // Dig out the pointee type if needed.
       if requiresArgument {
         guard let genericArguments else {
@@ -144,20 +144,14 @@ extension Swift2JavaVisitor {
       throw TypeTranslationError.unexpectedGenericArguments(type, genericArguments)
     }
 
-    // Nested types aren't mapped into Java.
-    if parent != nil {
-      throw TypeTranslationError.nestedType(type)
+    // Look up the imported types by name to resolve it to a nominal type.
+    let swiftTypeName = type.trimmedDescription // FIXME: This is a hack.
+    guard let resolvedNominal = translator.nominalResolution.resolveNominalType(swiftTypeName),
+          let importedNominal = translator.importedNominalType(resolvedNominal) else {
+      throw TypeTranslationError.unknown(type)
     }
 
-    // Swift types are passed indirectly.
-    // FIXME: Look up type names to figure out which ones are exposed and how.
-    return TranslatedType(
-      cCompatibleConvention: .indirect,
-      originalSwiftType: type,
-      cCompatibleSwiftType: "UnsafeMutablePointer<\(type)>",
-      cCompatibleJavaMemoryLayout: .heapObject,
-      javaType: .class(package: nil, name: name)
-    )
+    return importedNominal.translatedType
   }
 }
 
@@ -286,6 +280,6 @@ enum TypeTranslationError: Error {
   /// Missing generic arguments.
   case missingGenericArguments(TypeSyntax)
 
-  /// Type syntax nodes cannot be mapped.
-  case nestedType(TypeSyntax)
+  /// Unknown nominal type.
+  case unknown(TypeSyntax)
 }

Tests/JExtractSwiftTests/FuncImportTests.swift

@@ -53,6 +53,12 @@ final class MethodImportTests {
 
       @objc deinit
     }
+
+    // FIXME: Hack to allow us to translate "String", even though it's not
+    // actually available
+    // MANGLED NAME: $ss
+    public class String {
+    }
     """
 
   @Test func method_helloWorld() async throws {
@@ -161,7 +167,7 @@ final class MethodImportTests {
          * public func globalTakeIntLongString(i32: Int32, l: Int64, s: String)
          * }
          */
-        public static void globalTakeIntLongString(int i32, long l, String s) {
+        public static void globalTakeIntLongString(int i32, long l, com.example.swift.String s) {
             var mh$ = globalTakeIntLongString.HANDLE;
             try {
                 if (TRACE_DOWNCALLS) {