Revert pruning of redundant interfaces

This reverts the fix for SI-5278 made in 7a99c03
and later refined.

Direct parents enable use of `invokespecial` in the JVM,
so are not redundant. The motivating use case was the
proliferation of the `ScalaObject` parent in Android.
We no longer include that interfaces as a parent of
any class, and Scala 2.12 has left Android behind for
the time being due to use of Java 8 facilities.

Author: retronym

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

@@ -234,18 +234,10 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
     val allParents = classParents ++ classSym.annotations.flatMap(newParentForAnnotation)
 
-    // We keep the superClass when computing minimizeParents to eliminate more interfaces.
-    // Example: T can be eliminated from D
-    //   trait T
-    //   class C extends T
-    //   class D extends C with T
-    val interfaces = erasure.minimizeParents(allParents) match {
+    val interfaces = allParents match {
       case superClass :: ifs if !isInterfaceOrTrait(superClass.typeSymbol) =>
         ifs
       case ifs =>
-        // minimizeParents removes the superclass if it's redundant, for example:
-        //  trait A
-        //  class C extends Object with A  // minimizeParents removes Object
         ifs
     }
     interfaces.map(_.typeSymbol)

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

@@ -187,26 +187,6 @@ abstract class Erasure extends AddInterfaces
 
   private def isErasedValueType(tpe: Type) = tpe.isInstanceOf[ErasedValueType]
 
-  /* 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.
-   */
-  def minimizeParents(parents: List[Type]): List[Type] = if (parents.isEmpty) parents else {
-    def isInterfaceOrTrait(sym: Symbol) = sym.isInterface || sym.isTrait
-
-    var rest   = parents.tail
-    var leaves = collection.mutable.ListBuffer.empty[Type] += parents.head
-    while(rest.nonEmpty) {
-      val candidate = rest.head
-      val nonLeaf = leaves exists { t => t.typeSymbol isSubClass candidate.typeSymbol }
-      if(!nonLeaf) {
-        leaves = leaves filterNot { t => isInterfaceOrTrait(t.typeSymbol) && (candidate.typeSymbol isSubClass t.typeSymbol) }
-        leaves += candidate
-      }
-      rest = rest.tail
-    }
-    leaves.toList
-  }
-
 
   /** The Java signature of type 'info', for symbol sym. The symbol is used to give the right return
    *  type for constructors.
@@ -224,12 +204,11 @@ abstract class Erasure extends AddInterfaces
         case _ => tps
       }
 
-      val minParents = minimizeParents(parents)
       val validParents =
         if (isTraitSignature)
           // java is unthrilled about seeing interfaces inherit from classes
-          minParents filter (p => isInterfaceOrTrait(p.typeSymbol))
-        else minParents
+          parents filter (p => isInterfaceOrTrait(p.typeSymbol))
+        else parents
 
       val ps = ensureClassAsFirstParent(validParents)