Merge pull request #4699 from dotty-staging/decompile-fix-super

Fix printing super

Author: nicolasstucki

library/src/scala/tasty/util/ShowSourceCode.scala

@@ -321,10 +321,17 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
             this += "]"
         }
 
-      case Term.Super(qual, tptOpt) =>
-        printTree(qual)
-        this += ".super"
-        // TODO use tptOpt?
+      case Term.Super(qual, idOpt) =>
+        qual match {
+          case Term.This(Some(Id(name))) => this += name += "."
+          case Term.This(None) =>
+        }
+        this += "super"
+        for (id <- idOpt) {
+          val Id(name) = id
+          this += "[" += name += "]"
+        }
+        this
 
       case Term.Typed(term, tpt) =>
         tpt.tpe match {
@@ -442,13 +449,15 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
     }
 
     def printStats(stats: List[Tree], expr: Tree): Unit = {
-      def printSeparator(nextStats: List[Tree]) = {
+      def printSeparator(next: Tree): Unit = {
         // Avoid accidental application of opening `{` on next line with a double break
-        val next = if (nextStats.isEmpty) expr else nextStats.head
         next match {
           case Term.Block(DefDef("while$" | "doWhile$", _, _, _, _) :: Nil, _) => this += lineBreak()
           case Term.Block(_, _) => this += doubleLineBreak()
           case Term.Inlined(_, _, _) => this += doubleLineBreak()
+          case Term.Select(qual, _, _) => printSeparator(qual)
+          case Term.Apply(fn, _) => printSeparator(fn)
+          case Term.TypeApply(fn, _) => printSeparator(fn)
           case _ => this += lineBreak()
         }
       }
@@ -457,7 +466,7 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
           printTree(expr)
         case x :: xs =>
           printTree(x)
-          printSeparator(xs)
+          printSeparator(if (xs.isEmpty) expr else xs.head)
           printSeparated(xs)
       }
 

tests/pos/simpleSuper.decompiled

@@ -0,0 +1,18 @@
+/** Decompiled from out/posTestFromTasty/pos/simpleSuper/foo/A.class */
+package foo {
+  class A() {
+    def foo: scala.Int = 1
+  }
+}
+/** Decompiled from out/posTestFromTasty/pos/simpleSuper/foo/B.class */
+package foo {
+  trait B() extends java.lang.Object {
+    def foo: scala.Int = 2
+  }
+}
+/** Decompiled from out/posTestFromTasty/pos/simpleSuper/foo/C.class */
+package foo {
+  class C() extends foo.A() with foo.B {
+    override def foo: scala.Int = super.foo.+(super[B].foo)
+  }
+}

tests/pos/simpleSuper.scala

@@ -0,0 +1,13 @@
+package foo
+
+class A {
+  def foo: Int = 1
+}
+
+trait B {
+  def foo: Int = 2
+}
+
+class C extends A with B {
+  override def foo: Int = super.foo + super[B].foo
+}

tests/run/t4300.decompiled

@@ -0,0 +1,28 @@
+/** Decompiled from out/runTestFromTasty/run/t4300/A.class */
+trait A() extends java.lang.Object {
+  def f(): scala.Unit = scala.Predef.println("A")
+}
+/** Decompiled from out/runTestFromTasty/run/t4300/B.class */
+class B() extends A {
+  def b(): scala.Unit = super[A].f()
+  trait C() extends java.lang.Object {
+    def c(): scala.Unit = B.super[A].f()
+  }
+  def g(): scala.Unit = scala.Predef.intWrapper(0).until(1).foreach[scala.Unit](((i: scala.Int) => super[A].f()))
+  def h(): scala.Unit = scala.Predef.intWrapper(0).until(1).foreach[scala.Unit](((i: scala.Int) => B.super[A].f()))
+  override def f(): scala.Unit = scala.Predef.println("B")
+}
+/** Decompiled from out/runTestFromTasty/run/t4300/Test.class */
+object Test {
+  def main(args: scala.Array[scala.Predef.String]): scala.Unit = {
+    val b: B = new B()
+    b.b()
+
+    {
+      final class $anon() extends b.C()
+      (new $anon(): b.C)
+    }.c()
+    b.g()
+    b.h()
+  }
+}