Fix code gen for Outer.super[Q].foo

Consider

    class B extends T { class C { B.super[T].f }}

After flatten, that call is ` B$C.this.$outer().super[T].f()`.

In 2.11, mixin translates this to `A$class.f(B$C.this.$outer())`.
In 2.12, the tree is passed unchanged to the backend.

In `genApply` we assumed that in `Apply(Select(Super(qual, ... )))`,
`qual` is a `This` tree, so we just emitted `ALOAD_0`, which caused
the `$outer()` call to get lost. Now we invoke `genLoad(qual)`.

Fixes scala/bug#10290.

Author: lrytz

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

@@ -317,9 +317,12 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           }
           else {
             mnode.visitVarInsn(asm.Opcodes.ALOAD, 0)
-            generatedType =
-              if (tree.symbol == ArrayClass) ObjectRef
-              else classBTypeFromSymbol(claszSymbol)
+            // When compiling Array.scala, the constructor invokes 1Array.this.super.<init>1. The expectedType
+            // is `[Object` (computed by typeToBType, the type of This(Array) is `Array[T]`). If we would set
+            // the generatedType to `Array` below, the call to adapt at the end would fail.
+            if (tree.symbol != ArrayClass) {
+              generatedType = classBTypeFromSymbol(claszSymbol)
+            }
           }
 
         case Select(Ident(nme.EMPTY_PACKAGE_NAME), module) =>
@@ -551,7 +554,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
 
           generatedType = genTypeApply()
 
-        case Apply(fun @ Select(Super(_, _), _), args) =>
+        case Apply(fun @ Select(Super(qual, _), _), args) =>
           def initModule() {
             // we initialize the MODULE$ field immediately after the super ctor
             if (!isModuleInitialized &&
@@ -568,13 +571,9 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
               )
             }
           }
-          // 'super' call: Note: since constructors are supposed to
-          // return an instance of what they construct, we have to take
-          // special care. On JVM they are 'void', and Scala forbids (syntactically)
-          // to call super constructors explicitly and/or use their 'returned' value.
-          // therefore, we can ignore this fact, and generate code that leaves nothing
-          // on the stack (contrary to what the type in the AST says).
-          mnode.visitVarInsn(asm.Opcodes.ALOAD, 0)
+
+          // scala/bug#10290: qual can be `this.$outer()` (not just `this`), so we call genLoad (not jsut ALOAD_0)
+          genLoad(qual)
           genLoadArguments(args, paramTKs(app))
           generatedType = genCallMethod(fun.symbol, InvokeStyle.Super, app.pos)
           initModule()
@@ -1061,11 +1060,6 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       val receiverBType = classBTypeFromSymbol(receiverClass)
       val receiverName = receiverBType.internalName
 
-      def needsInterfaceCall(sym: Symbol) = {
-        sym.isTraitOrInterface ||
-          sym.isJavaDefined && sym.isNonBottomSubClass(definitions.ClassfileAnnotationClass)
-      }
-
       val jname  = method.javaSimpleName.toString
       val bmType = methodBTypeFromSymbol(method)
       val mdescr = bmType.descriptor

test/files/run/t10290.scala

@@ -0,0 +1,28 @@
+trait A1 {
+  private val s = "A1"
+  def f = s
+}
+
+trait A2 {
+  private val s = "A2"
+  def f = s
+}
+
+class B extends A1 with A2 {
+  override def f = "B"
+  class C {
+    def t1 = B.super[A1].f
+    def t2 = B.super[A2].f
+    def t3 = B.this.f
+  }
+}
+
+object Test {
+  def main(args : Array[String]) : Unit = {
+    val b = new B
+    val c = new b.C
+    assert(c.t1 == "A1")
+    assert(c.t2 == "A2")
+    assert(c.t3 == "B")
+  }
+}