Java2Swift: Drive recursion into nested subclasses from the outside

Rather than having the Java-to-Swift translator walking all nested
classes itself, provide it with the set of nested classes that should
be translated along with the enclosing class. This allows us to be
explicit about the naming of nested classes in the config file (where
we want to), while still getting the convenience of translating the
nested classes automatically for you by default.

Author: DougGregor

Sources/Java2Swift/JavaToSwift.swift

@@ -201,7 +201,7 @@ struct JavaToSwift: ParsableCommand {
     // Add the configuration for this module.
     translator.addConfiguration(config, forSwiftModule: moduleName)
 
-    // Load all of the requested classes.
+    // Load all of the explicitly-requested classes.
     let classLoader = try JavaClass<ClassLoader>(environment: environment)
       .getSystemClassLoader()!
     var javaClasses: [JavaClass<JavaObject>] = []
@@ -211,29 +211,50 @@ struct JavaToSwift: ParsableCommand {
         continue
       }
 
+      // Add this class to the list of classes we'll translate.
       javaClasses.append(javaClass)
+    }
+
+    // Find all of the nested classes for each class, adding them to the list
+    // of classes to be translated if they were already specified.
+    var allClassesToVisit = javaClasses
+    var currentClassIndex: Int = 0
+    while currentClassIndex < allClassesToVisit.count {
+      defer {
+        currentClassIndex += 1
+      }
+
+      // Find all of the nested classes that weren't explicitly translated
+      // already.
+      let currentClass = allClassesToVisit[currentClassIndex]
+      let nestedClasses: [JavaClass<JavaObject>] = currentClass.getClasses().compactMap { nestedClass in
+        guard let nestedClass else { return nil }
+
+        // If this is a local class, we're done.
+        let javaClassName = nestedClass.getName()
+        if javaClassName.isLocalJavaClass {
+          return nil
+        }
 
-      // Replace any $'s within the Java class name (which separate nested
-      // classes) with .'s (which represent nesting in Swift).
-      let translatedSwiftName = swiftName.replacing("$", with: ".")
-
-      // Note that we will be translating this Java class, so it is a known class.
-      translator.translatedClasses[javaClassName] = (translatedSwiftName, nil, true)
-
-      var classes: [JavaClass<JavaObject>?] = javaClass.getClasses()
-
-      // Go through all subclasses to find all of the classes to translate
-      while let internalClass = classes.popLast() {
-        if let internalClass {
-          let (javaName, swiftName) = names(from: internalClass.getName())
-          // If we have already been through this class, don't go through it again
-          guard translator.translatedClasses[javaName] == nil else { continue }
-          let currentClassName = swiftName
-          let currentSanitizedClassName = currentClassName.replacing("$", with: ".")
-          classes.append(contentsOf: internalClass.getClasses())
-          translator.translatedClasses[javaName] = (currentSanitizedClassName, nil, true)
+        // If this class has been explicitly mentioned, we're done.
+        if translator.translatedClasses[javaClassName] != nil {
+          return nil
         }
+
+        // Record this as a translated class.
+        let swiftName = javaClassName.defaultSwiftNameForJavaClass
+        translator.translatedClasses[javaClassName] = (swiftName, nil, true)
+        return nestedClass
       }
+
+      // If there were no new nested classes, there's nothing to do.
+      if nestedClasses.isEmpty {
+        continue
+      }
+
+      // Record all of the nested classes that we will visit.
+      translator.nestedClasses[currentClass.getName()] = nestedClasses
+      allClassesToVisit.append(contentsOf: nestedClasses)
     }
 
     // Translate all of the Java classes into Swift classes.
@@ -276,7 +297,7 @@ struct JavaToSwift: ParsableCommand {
       javaClassName = javaClassNameOpt
     }
 
-    return (javaClassName, swiftName)
+    return (javaClassName, swiftName.javaClassNameToCanonicalName)
   }
 
   mutating func writeContents(_ contents: String, to filename: String, description: String) throws {
@@ -317,12 +338,9 @@ struct JavaToSwift: ParsableCommand {
         continue
       }
 
-      // If any of the segments of the Java name start with a number, it's a
-      // local class that cannot be mapped into Swift.
-      for segment in entry.getName().split(separator: "$") {
-        if let firstChar = segment.first, firstChar.isNumber {
-          continue
-        }
+      // If this is a local class, it cannot be mapped into Swift.
+      if entry.getName().isLocalJavaClass {
+        continue
       }
 
       let javaCanonicalName = String(entry.getName().replacing("/", with: ".")
@@ -365,10 +383,10 @@ extension String {
   fileprivate var defaultSwiftNameForJavaClass: String {
     if let dotLoc = lastIndex(of: ".") {
       let afterDot = index(after: dotLoc)
-      return String(self[afterDot...])
+      return String(self[afterDot...]).javaClassNameToCanonicalName
     }
 
-    return self
+    return javaClassNameToCanonicalName
   }
 }
 
@@ -382,3 +400,22 @@ extension JavaClass<ClassLoader> {
   @JavaStaticMethod
   public func getSystemClassLoader() -> ClassLoader?
 }
+
+extension String {
+  /// Replace all of the $'s for nested names with "." to turn a Java class
+  /// name into a Java canonical class name,
+  fileprivate var javaClassNameToCanonicalName: String {
+    return replacing("$", with: ".")
+  }
+
+  /// Whether this is the name of an anonymous class.
+  fileprivate var isLocalJavaClass: Bool {
+    for segment in split(separator: "$") {
+      if let firstChar = segment.first, firstChar.isNumber {
+        return true
+      }
+    }
+
+    return false
+  }
+}

Sources/Java2SwiftLib/JavaTranslator.swift

@@ -43,6 +43,12 @@ package class JavaTranslator {
   /// methods will be implemented in Swift.
   package var swiftNativeImplementations: Set<String> = []
 
+  /// The set of nested classes that we should traverse from the given class,
+  /// indexed by the name of the class.
+  ///
+  /// TODO: Make JavaClass Hashable so we can index by the object?
+  package var nestedClasses: [String: [JavaClass<JavaObject>]] = [:]
+
   package init(
     swiftModuleName: String,
     environment: JNIEnvironment,
@@ -79,7 +85,6 @@ extension JavaTranslator {
   /// itself. This should only be used to refer to types that are built-in to
   /// JavaKit and therefore aren't captured in any configuration file.
   package static let defaultTranslatedClasses: [String: (swiftType: String, swiftModule: String?, isOptional: Bool)] = [
-    "java.lang.Class": ("JavaClass", "JavaKit", true),
     "java.lang.String": ("String", "JavaKit", false),
   ]
 }
@@ -391,14 +396,12 @@ extension JavaTranslator {
 
     topLevelDecls.append(classDecl)
 
-    let subClassDecls = javaClass.getClasses().compactMap {
-      $0.flatMap { clazz in
-        do {
-          return try translateClass(clazz)
-        } catch {
-          logUntranslated("Unable to translate '\(fullName)' subclass '\(clazz.getName())': \(error)")
-          return nil
-        }
+    let subClassDecls = (nestedClasses[fullName] ?? []).compactMap { clazz in
+      do {
+        return try translateClass(clazz)
+      } catch {
+        logUntranslated("Unable to translate '\(fullName)' subclass '\(clazz.getName())': \(error)")
+        return nil
       }
     }.flatMap(\.self)
 

Tests/Java2SwiftTests/Java2SwiftTests.swift

@@ -25,8 +25,15 @@ var jvm: JavaVirtualMachine {
 
 @JavaClass("java.time.Month")
 public struct JavaMonth {}
+
 @JavaClass("java.lang.ProcessBuilder")
-struct ProcessBuilder {}
+struct ProcessBuilder {
+  @JavaClass("java.lang.ProcessBuilder$Redirect")
+  struct Redirect {
+    @JavaClass("java.lang.ProcessBuilder$Redirect$Type")
+    struct JavaType { }
+  }
+}
 
 class Java2SwiftTests: XCTestCase {
   func testJavaLangObjectMapping() throws {
@@ -146,6 +153,10 @@ class Java2SwiftTests: XCTestCase {
         "java.lang.ProcessBuilder$Redirect": ("ProcessBuilder.Redirect", nil, true),
         "java.lang.ProcessBuilder$Redirect$Type": ("ProcessBuilder.Redirect.Type", nil, true),
       ],
+      nestedClasses: [
+        "java.lang.ProcessBuilder": [JavaClass<ProcessBuilder.Redirect>().as(JavaClass<JavaObject>.self)!],
+        "java.lang.ProcessBuilder$Redirect": [JavaClass<ProcessBuilder.Redirect.JavaType>().as(JavaClass<JavaObject>.self)!],
+      ],
       expectedChunks: [
         "import JavaKit",
         """
@@ -165,7 +176,6 @@ class Java2SwiftTests: XCTestCase {
       ]
     )
   }
-
 }
 
 @JavaClass("java.util.ArrayList")
@@ -184,6 +194,7 @@ func assertTranslatedClass<JavaClassType: AnyJavaObject>(
   translatedClasses: [
     String: (swiftType: String, swiftModule: String?, isOptional: Bool)
   ] = JavaTranslator.defaultTranslatedClasses,
+  nestedClasses: [String: [JavaClass<JavaObject>]] = [:],
   expectedChunks: [String],
   file: StaticString = #filePath,
   line: UInt = #line
@@ -196,8 +207,7 @@ func assertTranslatedClass<JavaClassType: AnyJavaObject>(
 
   translator.translatedClasses = translatedClasses
   translator.translatedClasses[javaType.fullJavaClassName] = (swiftTypeName, nil, true)
-
-
+  translator.nestedClasses = nestedClasses
   translator.startNewFile()
   let translatedDecls = try translator.translateClass(
     JavaClass<JavaObject>(