Do not print inlined calls tag in Expr.show

Also move logic that flattens blocks to the decompiler and make it stricter

Author: nicolasstucki

compiler/src/dotty/tools/dotc/quoted/TreeCleaner.scala

@@ -30,17 +30,6 @@ class TreeCleaner extends tpd.TreeMap {
     }
 
     super.transform(tree0) match {
-      case Block(Nil, expr1) => expr1
-      case Block(stats1, expr1) =>
-        val flatStats = stats1.flatMap {
-          case Block(stats2, expr2) => stats2 ::: expr2 :: Nil
-          case Literal(Constant(())) => Nil
-          case stat => stat :: Nil
-        }
-        expr1 match {
-          case Block(stats3, expr3) => Block(flatStats ::: stats3, expr3)
-          case expr3 => Block(flatStats, expr3)
-        }
       case tree1: TypeTree => TypeTree(tree1.tpe.subst(aliasesSyms, aliasesTypes))
       case tree1: Ident => aliases.get(tree1.symbol).getOrElse(tree1)
       case tree1 => tree1

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

@@ -237,6 +237,17 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         printTree(body) += " while "
         inParens(printTree(cond))
 
+      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)
 
@@ -363,34 +374,13 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
           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) =>
@@ -433,15 +423,72 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
     }
 
+    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) =>
+          stats1.foreach(extractFlatStats)
+          extractFlatStats(expr1)
+        case Term.Inlined(_, bindings, expansion) =>
+          bindings.foreach(extractFlatStats)
+          extractFlatStats(expansion)
+        case Term.Literal(Constant.Unit()) => // ignore
+        case stat => flatStats += stat
+      }
+      def extractFlatExpr(term: Term): Term = term match {
+        case Term.Block(stats1, expr1) =>
+          stats1.foreach(extractFlatStats)
+          extractFlatExpr(expr1)
+        case Term.Inlined(_, bindings, expansion) =>
+          bindings.foreach(extractFlatStats)
+          extractFlatExpr(expansion)
+        case term => term
+      }
+      stats.foreach(extractFlatStats)
+      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() {
   rewrite def foo: scala.Int = 9
-  def bar: scala.Int = { // inlined
-    9
-  }
+  def bar: scala.Int = 9
 }

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
 }