Avoid printing extra blocks and inline nodes

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -405,8 +405,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case SeqLiteral(elems, elemtpt) =>
         "[" ~ toTextGlobal(elems, ",") ~ " : " ~ toText(elemtpt) ~ "]"
       case tree @ Inlined(call, bindings, body) =>
-        (("/* inlined from " ~ toText(call) ~ " */ ") `provided`
-          !call.isEmpty && !homogenizedView && !ctx.settings.YshowNoInline.value) ~
+        (("/* inlined from " ~ (if (call.isEmpty) "outside" else toText(call)) ~ " */ ") `provided`
+          !homogenizedView && !ctx.settings.YshowNoInline.value) ~
         blockText(bindings :+ body)
       case tpt: untpd.DerivedTypeTree =>
         "<derived typetree watching " ~ summarized(toText(tpt.watched)) ~ ">"

compiler/test/dotc/pos-recompilation.whitelist

@@ -38,7 +38,6 @@ CoderTrait
 collectGenericCC
 collections_1
 comp-rec-test
-companions
 compile1
 conforms
 conformsWild
@@ -317,7 +316,6 @@ i831
 i864
 i877
 i878
-i880
 i903
 i938
 i939
@@ -438,7 +436,6 @@ propagate
 quote-1
 quote-lift-inline-params-b
 quote-non-static-macro
-quote-this
 range
 rangepos
 rangepos-anonapply
@@ -883,7 +880,6 @@ t613
 t6145
 t6146
 t615
-t6157
 t616
 t6184
 t6201

library/src/scala/tasty/reflect/Printers.scala

@@ -646,6 +646,17 @@ trait Printers
               printTree(body)
           }
 
+        case IsDefDef(ddef @ DefDef(name, targs, argss, _, rhsOpt)) if name.startsWith("$anonfun") =>
+          // Decompile lambda definition
+          assert(targs.isEmpty)
+          val args :: Nil = argss
+          val Some(rhs) = rhsOpt
+          inParens {
+            printArgsDefs(args)
+            this += " => "
+            printTree(rhs)
+          }
+
         case IsDefDef(ddef @ DefDef(name, targs, argss, tpt, rhs)) =>
           printDefAnnotations(ddef)
 
@@ -777,34 +788,13 @@ trait Printers
             case IsValDef(tree) => !tree.symbol.flags.isObject
             case _ => true
           }
+          printFlatBlock(stats, expr)
 
-          expr match {
-            case Term.Lambda(_, _) =>
-              // Decompile lambda from { def annon$(...) = ...; closure(annon$, ...)}
-              assert(stats.size == 1)
-              val DefDef(_, _, args :: Nil, _, Some(rhs)) :: Nil = stats
-              inParens {
-                printArgsDefs(args)
-                this += " => "
-                printTree(rhs)
-              }
-            case _ =>
-              this += "{"
-              indented {
-                printStats(stats, expr)
-              }
-              this += lineBreak() += "}"
-          }
-
-        case Term.Inlined(call, bindings, expansion) => // FIXME: Don't print Inlined with empty calls?
-          this += "{ // inlined"
-          indented {
-            printStats(bindings, expansion)
-          }
-          this += lineBreak() += "}"
+        case Term.Inlined(_, bindings, expansion) =>
+          printFlatBlock(bindings, expansion)
 
         case Term.Lambda(meth, tpt) =>
-          // Printed in Term.Block branch
+          // Printed in by it's DefDef
           this
 
         case Term.If(cond, thenp, elsep) =>
@@ -847,15 +837,80 @@ trait Printers
 
       }
 
+      def flatBlock(stats: List[Statement], expr: Term): (List[Statement], Term) = {
+        val flatStats = List.newBuilder[Statement]
+        def extractFlatStats(stat: Statement): Unit = stat match {
+          case Term.Block(stats1, expr1) =>
+            val it = stats1.iterator
+            while (it.hasNext)
+              extractFlatStats(it.next())
+            extractFlatStats(expr1)
+          case Term.Inlined(_, bindings, expansion) =>
+            val it = bindings.iterator
+            while (it.hasNext)
+              extractFlatStats(it.next())
+            extractFlatStats(expansion)
+          case Term.Literal(Constant.Unit()) => // ignore
+          case stat => flatStats += stat
+        }
+        def extractFlatExpr(term: Term): Term = term match {
+          case Term.Block(stats1, expr1) =>
+            val it = stats1.iterator
+            while (it.hasNext)
+              extractFlatStats(it.next())
+            extractFlatExpr(expr1)
+          case Term.Inlined(_, bindings, expansion) =>
+            val it = bindings.iterator
+            while (it.hasNext)
+              extractFlatStats(it.next())
+            extractFlatExpr(expansion)
+          case term => term
+        }
+        val it = stats.iterator
+        while (it.hasNext)
+          extractFlatStats(it.next())
+        val flatExpr = extractFlatExpr(expr)
+        (flatStats.result(), flatExpr)
+      }
+
+      def printFlatBlock(stats: List[Statement], expr: Term): Buffer = {
+        val (stats1, expr1) = flatBlock(stats, expr)
+        // Remove Term.Lambda nodes, lambdas are printed by their definition
+        val stats2 = stats1.filter { case Term.Lambda(_, _) => false; case _ => true }
+        val (stats3, expr3) = expr1 match {
+          case Term.Lambda(_, _) =>
+            val init :+ last  = stats2
+            (init, last)
+          case _ => (stats2, expr1)
+        }
+        if (stats3.isEmpty) {
+          printTree(expr3)
+        } else {
+          this += "{"
+          indented {
+            printStats(stats3, expr3)
+          }
+          this += lineBreak() += "}"
+        }
+      }
+
       def printStats(stats: List[Tree], expr: Tree): Unit = {
         def printSeparator(next: Tree): Unit = {
           // Avoid accidental application of opening `{` on next line with a double break
+          def rec(next: Tree): Unit = next match {
+            case Term.Block(stats, _) if stats.nonEmpty => this += doubleLineBreak()
+            case Term.Inlined(_, bindings, _) if bindings.nonEmpty => this += doubleLineBreak()
+            case Term.Select(qual, _) => rec(qual)
+            case Term.Apply(fn, _) => rec(fn)
+            case Term.TypeApply(fn, _) => rec(fn)
+            case _ => this += lineBreak()
+          }
           next match {
-            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 IsTerm(term) =>
+              flatBlock(Nil, term) match {
+                case (next :: _, _) => rec(next)
+                case (Nil, next) => rec(next)
+              }
             case _ => this += lineBreak()
           }
         }

tests/pos/i2104b.decompiled

@@ -34,10 +34,8 @@ case class Pair[A, B](_1: A, _2: B) {
 object Pair extends scala.AnyRef()
 /** Decompiled from out/posTestFromTasty/pos/i2104b/Test.class */
 object Test {
-  def main(args: scala.Array[scala.Predef.String]): scala.Unit = {
-    Cons.apply[scala.Option[scala.Int], scala.None.type](scala.Option.apply[scala.Int](1), scala.None) match {
-      case Cons(scala.Some(i), scala.None) =>
-        ()
-    }
+  def main(args: scala.Array[scala.Predef.String]): scala.Unit = Cons.apply[scala.Option[scala.Int], scala.None.type](scala.Option.apply[scala.Int](1), scala.None) match {
+    case Cons(scala.Some(i), scala.None) =>
+      ()
   }
-}
+}

tests/pos/i4526b.decompiled

@@ -1,11 +1,9 @@
 /** Decompiled from out/posTestFromTasty/pos/i4526b/Foo.class */
 class Foo() {
-  def justdoit(f: scala.Either[scala.Int, scala.Predef.String]): scala.Predef.String = {
-    f match {
-      case scala.Left(i) =>
-        i.toString()
-      case scala.Right(s) =>
-        (s: java.lang.String)
-    }
+  def justdoit(f: scala.Either[scala.Int, scala.Predef.String]): scala.Predef.String = f match {
+    case scala.Left(i) =>
+      i.toString()
+    case scala.Right(s) =>
+      (s: java.lang.String)
   }
 }

tests/pos/lambda.decompiled

@@ -1,11 +1,7 @@
 /** Decompiled from out/posTestFromTasty/pos/lambda/foo/Foo.class */
 package foo {
   class Foo() {
-    {
-      ((x: scala.Int) => {
-        2
-      })
-    }
+    ((x: scala.Int) => 2)
     val a: scala.Function1[scala.Int, scala.Int] = ((x: scala.Int) => x.*(x))
   }
 }

tests/pos/simpleDoWhile.decompiled

@@ -2,8 +2,6 @@
 class Foo() {
   def foo: scala.Unit = {
     var i: scala.Int = 1
-    do {
-      i = 0
-    } while (i.!=(0))
+    do i = 0 while (i.!=(0))
   }
 }

tests/pos/simpleInline.decompiled

@@ -1,7 +1,5 @@
 /** Decompiled from out/posTestFromTasty/pos/simpleInline/Foo.class */
 class Foo() {
   inline def foo: scala.Int = (9: scala.Int)
-  def bar: scala.Int = { // inlined
-    (9: scala.Int)
-  }
+  def bar: scala.Int = (9: scala.Int)
 }

tests/pos/simpleMatchCase.decompiled

@@ -1,10 +1,8 @@
 /** Decompiled from out/posTestFromTasty/pos/simpleMatchCase/Foo.class */
 class Foo() {
-  def foo: scala.Unit = {
-    "c" match {
-      case x =>
-        scala.Predef.println("a")
-        scala.Predef.println("b")
-    }
+  def foo: scala.Unit = "c" match {
+    case x =>
+      scala.Predef.println("a")
+      scala.Predef.println("b")
   }
 }

tests/pos/simpleWhile.decompiled

@@ -2,8 +2,6 @@
 class Foo() {
   def foo: scala.Unit = {
     var i: scala.Int = 1
-    while (i.!=(0)) {
-      i = 0
-    }
+    while (i.!=(0)) i = 0
   }
 }

tests/pos/t3869.decompiled

@@ -1,7 +1,5 @@
 /** Decompiled from out/posTestFromTasty/pos/t3869/Test.class */
 object Test {
   def f: scala.Unit = try return () finally while (true) ()
-  def main(args: scala.Array[scala.Predef.String]): scala.Unit = {
-    Test.f
-  }
+  def main(args: scala.Array[scala.Predef.String]): scala.Unit = Test.f
 }

tests/pos/t704.decompiled

@@ -16,11 +16,8 @@ trait E() extends java.lang.Object with D {
       val x1: scala.AnyRef = E.this.get_xxxx
       scala.Console.println(y)
     }
-
-    {
-      yyyy
-      ()
-    }
+    yyyy
+    ()
   }
 }
 /** Decompiled from out/posTestFromTasty/pos/t704/Go.class */

tests/run-with-compiler/quote-impure-by-name.check

@@ -1,3 +1 @@
-1 + {{ // inlined
-  Index.zero["bar", scala.Tuple2["baz", scala.Unit]]
-}}
+1 + {Index.zero["bar", scala.Tuple2["baz", scala.Unit]]}

tests/run-with-compiler/quote-nested-3.check

@@ -2,6 +2,5 @@
   type T = scala.Predef.String
   val x: java.lang.String = "foo"
   val z: T = x
-  ()
   (x: java.lang.String)
 }