Java2Swift: Always use the nearest imported superclass for the superclass

When we import a class from Java into Swift, we check whether its superclass
was also imported before generating a reference to that superclass. If it
isn't there, we fell back to JavaObject. That's too conservative, because
there might be a superclass in between that we could use.

Instead, walk up the superclass chain until we find the most-specific
superclass that *is* mapped into Swift, and use that as the generated
superclass. Additionally, use this as the basis for determining when we
need the "override" keyword when in the class-generating mode.

Author: DougGregor

Sources/Java2SwiftLib/JavaClassTranslator.swift

@@ -37,6 +37,10 @@ struct JavaClassTranslator {
   /// class.
   let swiftTypeName: String
 
+  /// The effective Java superclass object, which is the nearest
+  /// superclass that has been mapped into Swift.
+  let effectiveJavaSuperclass: JavaClass<JavaObject>?
+
   /// The Swift name of the superclass.
   let swiftSuperclass: String?
 
@@ -114,14 +118,24 @@ struct JavaClassTranslator {
     self.nestedClasses = translator.nestedClasses[fullName] ?? []
 
     // Superclass.
-    if !javaClass.isInterface(), let javaSuperclass = javaClass.getSuperclass() {
-      do {
-        self.swiftSuperclass = try translator.getSwiftTypeName(javaSuperclass, preferValueTypes: false).swiftName
-      } catch {
-        translator.logUntranslated("Unable to translate '\(fullName)' superclass: \(error)")
-        self.swiftSuperclass = nil
+    if !javaClass.isInterface() {
+      var javaSuperclass = javaClass.getSuperclass()
+      var swiftSuperclass: String? = nil
+      while let javaSuperclassNonOpt = javaSuperclass {
+        do {
+          swiftSuperclass = try translator.getSwiftTypeName(javaSuperclassNonOpt, preferValueTypes: false).swiftName
+          break
+        } catch {
+          translator.logUntranslated("Unable to translate '\(fullName)' superclass: \(error)")
+        }
+
+        javaSuperclass = javaSuperclassNonOpt.getSuperclass()
       }
+
+      self.effectiveJavaSuperclass = javaSuperclass
+      self.swiftSuperclass = swiftSuperclass
     } else {
+      self.effectiveJavaSuperclass = nil
       self.swiftSuperclass = nil
     }
 
@@ -646,7 +660,7 @@ extension JavaClassTranslator {
   /// Determine whether this method is an override of another Java
   /// method.
   func isOverride(_ method: Method) -> Bool {
-    guard let javaSuperclass = javaClass.getSuperclass() else {
+    guard let javaSuperclass = effectiveJavaSuperclass else {
       return false
     }
 

Tests/Java2SwiftTests/Java2SwiftTests.swift

@@ -327,8 +327,79 @@ class Java2SwiftTests: XCTestCase {
       ]
     )
   }
+
+  func testURLLoaderSkipMappingAsClass() throws {
+    // URLClassLoader actually inherits from SecureClassLoader. However,
+    // that type wasn't mapped into Swift, so we find the nearest
+    // superclass that was mapped into Swift.
+    try assertTranslatedClass(
+      URLClassLoader.self,
+      swiftTypeName: "URLClassLoader",
+      asClass: true,
+      translatedClasses: [
+        "java.lang.Object" : ("JavaObject", "JavaKit"),
+        "java.lang.ClassLoader" : ("ClassLoader", "JavaKit"),
+        "java.net.URL" : ("URL", "JavaKitNetwork"),
+      ],
+      expectedChunks: [
+        "import JavaKit",
+        """
+        @JavaClass("java.net.URLClassLoader")
+        open class URLClassLoader: ClassLoader {
+        """,
+        """
+          @JavaMethod
+          open func close() throws
+        """,
+        """
+          @JavaMethod
+          open override func findResource(_ arg0: String) -> URL!
+        """,
+      ]
+    )
+  }
+
+  func testURLLoaderSkipTwiceMappingAsClass() throws {
+    // URLClassLoader actually inherits from SecureClassLoader. However,
+    // that type wasn't mapped into Swift here, nor is ClassLoader,
+    // so we fall back to JavaObject.
+    try assertTranslatedClass(
+      URLClassLoader.self,
+      swiftTypeName: "URLClassLoader",
+      asClass: true,
+      translatedClasses: [
+        "java.lang.Object" : ("JavaObject", "JavaKit"),
+        "java.net.URL" : ("URL", "JavaKitNetwork"),
+      ],
+      expectedChunks: [
+        "import JavaKit",
+        """
+        @JavaClass("java.net.URLClassLoader")
+        open class URLClassLoader: JavaObject {
+        """,
+        """
+          @JavaMethod
+          open func close() throws
+        """,
+        """
+          @JavaMethod
+          open func findResource(_ arg0: String) -> URL!
+        """,
+      ]
+    )
+  }
 }
 
+@JavaClass("java.lang.ClassLoader")
+public struct ClassLoader { }
+
+@JavaClass("java.security.SecureClassLoader")
+public struct SecureClassLoader { }
+
+@JavaClass("java.net.URLClassLoader")
+public struct URLClassLoader { }
+
+
 @JavaClass("java.util.ArrayList")
 public struct MyArrayList<E: AnyJavaObject> {
 }