Make nested classes explicitly-specifiable and work through some integration issues (#118)

* Java2Swift: Add a test for a generic static method

* Drop the "canonicalClassName" from JavaTypes because it is now incorrect

We're using the "normal" name now that uses $ for nested classes.

* Remove dead code behind a `#if false`

* Teach the Java2Swift plugin to match the nested type naming scheme for Java2Swift

* Regenerate java.util.jar.Attributes with the "isFinal" change

* 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.

* Update JavaSieve example now that we're handling nested classes

* Java2Swift: Use the parent's Swift type name to form nested type names

* Escape member types named "Type"

* Work around issues with Java classes named "Type" by renaming them "JavaType"

This is deeply unfortunate, but we need compile-side fixes for
nested types named "Type" to work.

Author: DougGregor

Plugins/Java2SwiftPlugin/Java2SwiftPlugin.swift

@@ -90,7 +90,8 @@ struct Java2SwiftBuildToolPlugin: BuildToolPlugin {
     /// Determine the set of Swift files that will be emitted by the Java2Swift
     /// tool.
     let outputSwiftFiles = config.classes.map { (javaClassName, swiftName) in
-      outputDirectory.appending(path: "\(swiftName).swift")
+      let swiftNestedName = swiftName.replacingOccurrences(of: ".", with: "+")
+      return outputDirectory.appending(path: "\(swiftNestedName).swift")
     }
 
     // Find the Java .class files generated from prior plugins.

Samples/JavaSieve/Sources/JavaSieve/Java2Swift.config

@@ -20,6 +20,7 @@
     "com.gazman.quadratic_sieve.data.VectorWorkData" : "VectorWorkData",
     "com.gazman.quadratic_sieve.debug.Analytics" : "Analytics",
     "com.gazman.quadratic_sieve.debug.AssertUtils" : "AssertUtils",
+    "com.gazman.quadratic_sieve.debug.AssertUtils$Tester" : "AssertUtils.Tester",
     "com.gazman.quadratic_sieve.debug.Logger" : "Logger",
     "com.gazman.quadratic_sieve.fact.TrivialDivision" : "TrivialDivision",
     "com.gazman.quadratic_sieve.primes.BigPrimes" : "BigPrimes",

Sources/Java2Swift/JavaToSwift.swift

@@ -201,48 +201,69 @@ struct JavaToSwift: ParsableCommand {
     // Add the configuration for this module.
     translator.addConfiguration(config, forSwiftModule: moduleName)
 
-    // Load all of the requested classes.
-    #if false
-    let classLoader = URLClassLoader(
-      [
-        try URL("file://\(classPath)", environment: environment)
-      ],
-      environment: environment
-    )
-    #else
+    // Load all of the explicitly-requested classes.
     let classLoader = try JavaClass<ClassLoader>(environment: environment)
       .getSystemClassLoader()!
-    #endif
     var javaClasses: [JavaClass<JavaObject>] = []
     for (javaClassName, swiftName) in config.classes {
       guard let javaClass = try classLoader.loadClass(javaClassName) else {
         print("warning: could not find Java class '\(javaClassName)'")
         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
+      }
+
+      // The current class we're in.
+      let currentClass = allClassesToVisit[currentClassIndex]
+      guard let currentSwiftName = translator.translatedClasses[currentClass.getName()]?.swiftType else {
+        continue
+      }
+
+      // Find all of the nested classes that weren't explicitly translated
+      // already.
+      let nestedClasses: [JavaClass<JavaObject>] = currentClass.getClasses().compactMap { nestedClass in
+        guard let nestedClass else { 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 is a local class, we're done.
+        let javaClassName = nestedClass.getName()
+        if javaClassName.isLocalJavaClass {
+          return nil
         }
+
+        // If this class has been explicitly mentioned, we're done.
+        if translator.translatedClasses[javaClassName] != nil {
+          return nil
+        }
+
+        // Record this as a translated class.
+        let swiftUnqualifiedName = javaClassName.javaClassNameToCanonicalName
+          .defaultSwiftNameForJavaClass
+
+
+        let swiftName = "\(currentSwiftName).\(swiftUnqualifiedName)"
+        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.
@@ -285,7 +306,7 @@ struct JavaToSwift: ParsableCommand {
       javaClassName = javaClassNameOpt
     }
 
-    return (javaClassName, swiftName)
+    return (javaClassName, swiftName.javaClassNameToCanonicalName)
   }
 
   mutating func writeContents(_ contents: String, to filename: String, description: String) throws {
@@ -326,12 +347,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: ".")
@@ -374,10 +392,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.adjustedSwiftTypeName
     }
 
-    return self
+    return javaClassNameToCanonicalName.adjustedSwiftTypeName
   }
 }
 
@@ -391,3 +409,30 @@ 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
+  }
+
+  /// Adjust type name for "bad" type names that don't work well in Swift.
+  fileprivate var adjustedSwiftTypeName: String {
+    switch self {
+    case "Type": return "JavaType"
+    default: return self
+    }
+  }
+}

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),
   ]
 }
@@ -165,19 +170,28 @@ extension JavaTranslator {
     let javaType = try JavaType(javaTypeName: javaClass.getName())
     let isSwiftOptional = javaType.isSwiftOptional
     return (
-      try javaType.swiftTypeName(resolver: self.getSwiftTypeNameFromJavaClassName(_:)),
+      try javaType.swiftTypeName { javaClassName in
+        try self.getSwiftTypeNameFromJavaClassName(javaClassName)
+      },
       isSwiftOptional
     )
   }
 
   /// Map a Java class name to its corresponding Swift type.
-  private func getSwiftTypeNameFromJavaClassName(_ name: String) throws -> String {
+  private func getSwiftTypeNameFromJavaClassName(
+    _ name: String,
+    escapeMemberNames: Bool = true
+  ) throws -> String {
     if let translated = translatedClasses[name] {
       // Note that we need to import this Swift module.
       if let swiftModule = translated.swiftModule, swiftModule != swiftModuleName {
         importedSwiftModules.insert(swiftModule)
       }
 
+      if escapeMemberNames {
+        return translated.swiftType.escapingSwiftMemberNames
+      }
+
       return translated.swiftType
     }
 
@@ -192,7 +206,7 @@ extension JavaTranslator {
   /// JavaClass to house static methods.
   package func translateClass(_ javaClass: JavaClass<JavaObject>) throws -> [DeclSyntax] {
     let fullName = javaClass.getName()
-    let swiftTypeName = try getSwiftTypeNameFromJavaClassName(fullName)
+    let swiftTypeName = try getSwiftTypeNameFromJavaClassName(fullName, escapeMemberNames: false)
     let (swiftParentType, swiftInnermostTypeName) = swiftTypeName.splitSwiftTypeName()
 
     // If the swift parent type has not been translated, don't try to translate this one
@@ -391,14 +405,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)
 
@@ -633,3 +645,30 @@ extension JavaTranslator {
     }
   }
 }
+
+extension String {
+  /// Escape Swift types that involve member name references like '.Type'
+  fileprivate var escapingSwiftMemberNames: String {
+    var count = 0
+    return split(separator: ".").map { component in
+      defer {
+        count += 1
+      }
+
+      if count > 0 && component.memberRequiresBackticks {
+        return "`\(component)`"
+      }
+
+      return String(component)
+    }.joined(separator: ".")
+  }
+}
+
+extension Substring {
+  fileprivate var memberRequiresBackticks: Bool {
+    switch self {
+    case "Type": return true
+    default: return false
+    }
+  }
+}

Sources/JavaKit/Optional+JavaObject.swift

@@ -37,7 +37,7 @@ extension Optional: JavaValue where Wrapped: AnyJavaObject {
   }
 
   public static var javaType: JavaType {
-    JavaType(canonicalClassName: Wrapped.fullJavaClassName)
+    JavaType(className: Wrapped.fullJavaClassName)
   }
 
   public static func jniMethodCall(

Sources/JavaKitJar/generated/Attributes.swift

@@ -133,57 +133,57 @@ extension Attributes {
   }
 }
 extension JavaClass<Attributes.Name> {
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var MANIFEST_VERSION: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var SIGNATURE_VERSION: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var CONTENT_TYPE: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var CLASS_PATH: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var MAIN_CLASS: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var SEALED: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var EXTENSION_LIST: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var EXTENSION_NAME: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var EXTENSION_INSTALLATION: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var IMPLEMENTATION_TITLE: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var IMPLEMENTATION_VERSION: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var IMPLEMENTATION_VENDOR: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var IMPLEMENTATION_VENDOR_ID: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var IMPLEMENTATION_URL: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var SPECIFICATION_TITLE: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var SPECIFICATION_VERSION: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var SPECIFICATION_VENDOR: Attributes.Name?
 
-  @JavaStaticField
+  @JavaStaticField(isFinal: true)
   public var MULTI_RELEASE: Attributes.Name?
 }

Sources/JavaTypes/JavaType+JavaSource.swift

@@ -32,7 +32,7 @@ extension JavaType {
       self = try JavaType(mangledName: name)
 
     case let className:
-      self = JavaType(canonicalClassName: className)
+      self = JavaType(className: className)
     }
   }
 }