SI-9044 Fix order of interfaces in classfiles

It was reversed since ced3ca8ae1. The reason is that the backend used
`mixinClasses` to obtain the parents of a class, which returns them in
linearization order.

`mixinClasses` als returns all ancestors (not only direct parents),
which means more work for `minimizeInterfaces`. This was introduced
in cd62f52 for unclear reasons. So we switch back to using `parents`.

5 files changed, 45 insertions, 49 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
index 328ec8a033..a5f33aa786 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
@@ -162,4 +162,32 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
       assoc.collectFirst {
         case (`nme`.value, LiteralAnnotArg(Constant(value: Symbol))) => value
       }).flatten.getOrElse(AnnotationRetentionPolicyClassValue)
+
+  def implementedInterfaces(classSym: Symbol): List[Symbol] = {
+    // Additional interface parents based on annotations and other cues
+    def newParentForAnnotation(ann: AnnotationInfo): Option[Type] = ann.symbol match {
+      case RemoteAttr => Some(RemoteInterfaceClass.tpe)
+      case _          => None
+    }
+
+    def isInterfaceOrTrait(sym: Symbol) = sym.isInterface || sym.isTrait
+
+    val allParents = classSym.info.parents ++ 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 {
+      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)
+  }
 }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index 3b7cbd6392..2238221c83 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -114,7 +114,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     val superClass = if (superClassSym == NoSymbol) None
                      else Some(classBTypeFromSymbol(superClassSym))
 
-    val interfaces = getSuperInterfaces(classSym).map(classBTypeFromSymbol)
+    val interfaces = implementedInterfaces(classSym).map(classBTypeFromSymbol)
 
     val flags = javaFlags(classSym)
 
@@ -182,28 +182,6 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     classBType
   }
 
-  /**
-   * All interfaces implemented by a class, except for those inherited through the superclass.
-   *
-   * TODO @lry share code with GenASM
-   */
-  private def getSuperInterfaces(classSym: Symbol): List[Symbol] = {
-
-    // Additional interface parents based on annotations and other cues
-    def newParentForAnnotation(ann: AnnotationInfo): Symbol = ann.symbol match {
-      case RemoteAttr => RemoteInterfaceClass
-      case _          => NoSymbol
-    }
-
-    val superInterfaces0: List[Symbol] = classSym.mixinClasses
-    val superInterfaces = existingSymbols(superInterfaces0 ++ classSym.annotations.map(newParentForAnnotation)).distinct
-
-    assert(!superInterfaces.contains(NoSymbol), s"found NoSymbol among: ${superInterfaces.mkString(", ")}")
-    assert(superInterfaces.forall(s => s.isInterface || s.isTrait), s"found non-interface among: ${superInterfaces.mkString(", ")}")
-
-    erasure.minimizeInterfaces(superInterfaces.map(_.info)).map(_.typeSymbol)
-  }
-
   private def buildNestedInfo(innerClassSym: Symbol): Option[NestedInfo] = {
     assert(innerClassSym.isClass, s"Cannot build NestedInfo for non-class symbol $innerClassSym")
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index e56a20c2e7..7626df312e 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -1206,22 +1206,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
 
     def serialVUID: Option[Long] = genBCode.serialVUID(clasz.symbol)
 
-    private def getSuperInterfaces(c: IClass): Array[String] = {
-
-        // Additional interface parents based on annotations and other cues
-        def newParentForAttr(ann: AnnotationInfo): Symbol = ann.symbol match {
-          case RemoteAttr       => RemoteInterfaceClass
-          case _                => NoSymbol
-        }
-
-      val ps = c.symbol.info.parents
-      val superInterfaces0: List[Symbol] = if(ps.isEmpty) Nil else c.symbol.mixinClasses
-      val superInterfaces = existingSymbols(superInterfaces0 ++ c.symbol.annotations.map(newParentForAttr)).distinct
-
-      if(superInterfaces.isEmpty) EMPTY_STRING_ARRAY
-      else mkArray(erasure.minimizeInterfaces(superInterfaces.map(_.info)).map(t => javaName(t.typeSymbol)))
-    }
-
     var clasz:    IClass = _           // this var must be assigned only by genClass()
     var jclass:   asm.ClassWriter = _  // the classfile being emitted
     var thisName: String = _           // the internal name of jclass
@@ -1242,7 +1226,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
       val ps = c.symbol.info.parents
       val superClass: String = if(ps.isEmpty) JAVA_LANG_OBJECT.getInternalName else javaName(ps.head.typeSymbol)
 
-      val ifaces = getSuperInterfaces(c)
+      val ifaces: Array[String] = implementedInterfaces(c.symbol).map(javaName)(collection.breakOut)
 
       val thisSignature = getGenericSignature(c.symbol, c.symbol.owner)
       val flags = mkFlags(
diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index b6af19250e..79833e273d 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -185,22 +185,22 @@ abstract class Erasure extends AddInterfaces
 
   private def isErasedValueType(tpe: Type) = tpe.isInstanceOf[ErasedValueType]
 
-  /* Drop redundant interfaces (ones which are implemented by some other parent) from the immediate parents.
+  /* 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 minimizeInterfaces(lstIfaces: List[Type]): List[Type] = {
-    var rest   = lstIfaces
-    var leaves = List.empty[Type]
-    while(!rest.isEmpty) {
+  def minimizeParents(parents: List[Type]): List[Type] = {
+    var rest   = parents
+    var leaves = collection.mutable.ListBuffer.empty[Type]
+    while(rest.nonEmpty) {
       val candidate = rest.head
       val nonLeaf = leaves exists { t => t.typeSymbol isSubClass candidate.typeSymbol }
       if(!nonLeaf) {
-        leaves = candidate :: (leaves filterNot { t => candidate.typeSymbol isSubClass t.typeSymbol })
+        leaves = leaves filterNot { t => candidate.typeSymbol isSubClass t.typeSymbol }
+        leaves += candidate
       }
       rest = rest.tail
     }
-
-    leaves.reverse
+    leaves.toList
   }
 
 
@@ -220,7 +220,7 @@ abstract class Erasure extends AddInterfaces
         case _ => tps
       }
 
-      val minParents = minimizeInterfaces(parents)
+      val minParents = minimizeParents(parents)
       val validParents =
         if (isTraitSignature)
           // java is unthrilled about seeing interfaces inherit from classes
diff --git a/test/files/jvm/t9044.scala b/test/files/jvm/t9044.scala
new file mode 100644
index 0000000000..b1073325e8
--- /dev/null
+++ b/test/files/jvm/t9044.scala
@@ -0,0 +1,6 @@
+trait A
+trait B
+object Test extends A with B with App {
+  val is = Test.getClass.getInterfaces.mkString(", ")
+  assert(is == "interface A, interface B, interface scala.App", is)
+}