Don't minimize reduntant parents used in super calls

Also removes the special-case in minimizeParents for Java interfaces,
they can now be removed since we know which ones are used for super
calls

Author: lrytz

src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala

@@ -252,7 +252,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
     val allParents = classParents ++ classSym.annotations.flatMap(newParentForAnnotation)
 
-    val minimizedParents = if (classSym.isJavaDefined) allParents else erasure.minimizeParents(allParents)
+    val minimizedParents = if (classSym.isJavaDefined) allParents else erasure.minimizeParents(classSym, allParents)
     // We keep the superClass when computing minimizeParents to eliminate more interfaces.
     // Example: T can be eliminated from D
     //   trait T

src/compiler/scala/tools/nsc/transform/Erasure.scala

@@ -28,6 +28,8 @@ abstract class Erasure extends InfoTransform
 
   val phaseName: String = "erasure"
 
+  val requiredDirectInterfaces = perRunCaches.newAnyRefMap[Symbol, mutable.Set[Symbol]]()
+
   def newTransformer(unit: CompilationUnit): Transformer =
     new ErasureTransformer(unit)
 
@@ -191,26 +193,21 @@ abstract class Erasure extends InfoTransform
 
   /* Drop redundant types (ones which are implemented by some other parent) from the immediate parents.
    * This is important on Android because there is otherwise an interface explosion.
-   * This is now restricted to Scala defined ancestors: a Java defined ancestor may need to be listed
-   * as an immediate parent to support an `invokespecial`.
    */
-  def minimizeParents(parents: List[Type]): List[Type] = if (parents.isEmpty) parents else {
-    def isRedundantParent(parent: Symbol, candidate: Symbol) =
-      !parent.isJavaDefined &&
-        parent.isTraitOrInterface &&
-        candidate.isSubClass(parent)
-
+  def minimizeParents(cls: Symbol, parents: List[Type]): List[Type] = if (parents.isEmpty) parents else {
+    val requiredDirect: Symbol => Boolean = requiredDirectInterfaces.getOrElse(cls, Set.empty)
     var rest   = parents.tail
     var leaves = collection.mutable.ListBuffer.empty[Type] += parents.head
     while (rest.nonEmpty) {
       val candidate = rest.head
-      if (candidate.typeSymbol.isJavaDefined && candidate.typeSymbol.isInterface) leaves += candidate
-      else {
-        val nonLeaf = leaves exists { t => t.typeSymbol isSubClass candidate.typeSymbol }
-        if (!nonLeaf) {
-          leaves = leaves filterNot { t => isRedundantParent(t.typeSymbol, candidate.typeSymbol) }
-          leaves += candidate
+      val candidateSym = candidate.typeSymbol
+      val required = requiredDirect(candidateSym) || !leaves.exists(t => t.typeSymbol isSubClass candidateSym)
+      if (required) {
+        leaves = leaves filter { t =>
+          val ts = t.typeSymbol
+          requiredDirect(ts) || !ts.isTraitOrInterface || !candidateSym.isSubClass(ts)
         }
+        leaves += candidate
       }
       rest = rest.tail
     }
@@ -224,7 +221,7 @@ abstract class Erasure extends InfoTransform
   def javaSig(sym0: Symbol, info: Type, markClassUsed: Symbol => Unit): Option[String] = enteringErasure {
     val isTraitSignature = sym0.enclClass.isTrait
 
-    def superSig(parents: List[Type]) = {
+    def superSig(cls: Symbol, parents: List[Type]) = {
       def isInterfaceOrTrait(sym: Symbol) = sym.isInterface || sym.isTrait
 
       // a signature should always start with a class
@@ -234,7 +231,7 @@ abstract class Erasure extends InfoTransform
         case _ => tps
       }
 
-      val minParents = minimizeParents(parents)
+      val minParents = minimizeParents(cls, parents)
       val validParents =
         if (isTraitSignature)
           // java is unthrilled about seeing interfaces inherit from classes
@@ -373,7 +370,7 @@ abstract class Erasure extends InfoTransform
         case RefinedType(parents, decls) =>
           jsig(intersectionDominator(parents), primitiveOK = primitiveOK)
         case ClassInfoType(parents, _, _) =>
-          superSig(parents)
+          superSig(tp.typeSymbol, parents)
         case AnnotatedType(_, atp) =>
           jsig(atp, existentiallyBound, toplevel, primitiveOK)
         case BoundedWildcardType(bounds) =>
@@ -1185,6 +1182,10 @@ abstract class Erasure extends InfoTransform
                 reporter.error(tree.pos, s"Unable to emit super reference to ${sym.fullLocationString}, $owner is not accessible in ${localTyper.context.enclClass.owner}")
                 owner
             }
+
+            if (sym.isJavaDefined && qualSym.isTraitOrInterface)
+              requiredDirectInterfaces.getOrElseUpdate(localTyper.context.enclClass.owner, mutable.Set.empty) += qualSym
+
             if (qualSym != owner)
               tree.updateAttachment(new QualTypeSymAttachment(qualSym))
           } else if (!isJvmAccessible(owner, localTyper.context)) {

src/compiler/scala/tools/nsc/transform/Mixin.scala

@@ -218,13 +218,17 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL with AccessorSynthes
             if (isMemberOfClazz) {
               def genForwarder(required: Boolean): Unit = {
                 val owner = member.owner
-                if (owner.isJavaDefined && owner.isInterface && !clazz.parentSymbols.contains(owner)) {
+                val isJavaInterface = owner.isJavaDefined && owner.isInterface
+                if (isJavaInterface && !clazz.parentSymbols.contains(owner)) {
                   if (required) {
                     val text = s"Unable to implement a mixin forwarder for $member in $clazz unless interface ${owner.name} is directly extended by $clazz."
                     reporter.error(clazz.pos, text)
                   }
-                } else
+                } else {
+                  if (isJavaInterface)
+                    erasure.requiredDirectInterfaces.getOrElseUpdate(clazz, mutable.Set.empty) += owner
                   cloneAndAddMixinMember(mixinClass, member).asInstanceOf[TermSymbol] setAlias member
+                }
               }
 
               // `member` is a concrete method defined in `mixinClass`, which is a base class of
@@ -291,9 +295,12 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL with AccessorSynthes
               reporter.error(clazz.pos, "Member %s of mixin %s is missing a concrete super implementation.".format(
                 mixinMember.alias, mixinClass))
             case alias1 =>
-              if (alias1.owner.isJavaDefined && alias1.owner.isInterface && !clazz.parentSymbols.contains(alias1.owner)) {
-                val suggestedParent = exitingTyper(clazz.info.baseType(alias1.owner))
-                reporter.error(clazz.pos, s"Unable to implement a super accessor required by trait ${mixinClass.name} unless $suggestedParent is directly extended by $clazz.")
+              if (alias1.owner.isJavaDefined && alias1.owner.isInterface) {
+                if (!clazz.parentSymbols.contains(alias1.owner)) {
+                  val suggestedParent = exitingTyper(clazz.info.baseType(alias1.owner))
+                  reporter.error(clazz.pos, s"Unable to implement a super accessor required by trait ${mixinClass.name} unless $suggestedParent is directly extended by $clazz.")
+                } else
+                  erasure.requiredDirectInterfaces.getOrElseUpdate(clazz, mutable.Set.empty) += alias1.owner
               }
               superAccessor.asInstanceOf[TermSymbol] setAlias alias1
           }

test/files/neg/trait-defaults-super.scala

@@ -12,10 +12,3 @@ trait T extends java.lang.Iterable[String] {
   def iterator(): java.util.Iterator[String] = java.util.Collections.emptyList().iterator()
 }
 class C extends T
-object Test {
-  def main(args: Array[String]): Unit = {
-    val t: T = new C
-    t.spliterator
-    t.foo
-  }
-}

test/files/pos/trait-defaults-super.scala test/files/run/trait-defaults-super.scalatest/files/pos/trait-defaults-super.scala renamed to test/files/run/trait-defaults-super.scala

@@ -14,7 +14,10 @@ trait T extends java.lang.Iterable[String] {
 class C extends T with java.lang.Iterable[String] // super accessor is okay with Iterable as a direct parent
 object Test {
   def main(args: Array[String]): Unit = {
-    val t: T = new C
+    val c = new C
+    c.spliterator
+    c.foo
+    val t: T = c
     t.spliterator
     t.foo
   }

test/junit/scala/lang/traits/BytecodeTest.scala

@@ -407,6 +407,20 @@ class BytecodeTest extends BytecodeTesting {
     assert(ins contains Invoke(INVOKESPECIAL, "T", "f", "()I", true), ins.stringLines)
   }
 
+  @Test
+  def noMinimizeScalaTraitAccessingJavaMember(): Unit = {
+    val jCode = List("interface A { default int f() { return 1; } }" -> "A.java")
+    val code =
+      """trait U extends A
+        |trait V extends U
+        |class C extends U with V { def t = super.f() }
+      """.stripMargin
+    val List(c, u, v) = compileClasses(code, jCode)
+    assertEquals(c.interfaces.asScala.toList.sorted, List("U", "V"))
+    val ins = getMethod(c, "t").instructions
+    assert(ins contains Invoke(INVOKESPECIAL, "U", "f", "()I", true), ins.stringLines)
+  }
+
   def ifs(c: ClassNode, expected: List[String]) = assertEquals(expected, c.interfaces.asScala.toList.sorted)
   def invSt(m: Method, receiver: String, method: String = "f$", itf: Boolean = true): Unit =
     assert(m.instructions contains Invoke(INVOKESTATIC, receiver, method, s"(L$receiver;)I", itf), m.instructions.stringLines)