Print double bracks after statements to avoid ambiguity

For example, the first snippet is `foo.apply(...)` and the second is
eval `foo` and then eval the block.

```scala
foo
{
 ...
}
```

```scala
foo

{
 ...
}
```

Author: nicolasstucki

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

@@ -191,8 +191,7 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
           case stats =>
             this += "{"
             indented {
-              this += lineBreak()
-              printTrees(stats, lineBreak())
+              printStats(stats.init, stats.last)
             }
             this += lineBreak() += "}"
         }
@@ -205,8 +204,9 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
           case stats =>
             this += "{"
             indented {
+              printStats(stats.init, stats.last)
               this += lineBreak()
-              printTrees(stats, lineBreak())
+              printTree(stats.last)
             }
             this += lineBreak() += "}"
         }
@@ -327,28 +327,19 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
             this += ")"
           case _ =>
             this += "{"
+            val (stats1, expr1) =
+              if (isLoopEntryPoint(expr)) (stats.init, stats.last)
+              else (stats, expr)
             indented {
-              if (!stats.isEmpty) {
-                this += lineBreak()
-                printTrees(stats, lineBreak())
-              }
-              if (!isLoopEntryPoint(expr)) {
-                this += lineBreak()
-                printTree(expr)
-              }
+              printStats(stats1, expr1)
             }
             this += lineBreak() += "}"
         }
 
       case Term.Inlined(call, bindings, expansion) =>
-        sb.append("{ // inlined")
+        this += "{ // inlined"
         indented {
-          if (!bindings.isEmpty) {
-            this += lineBreak()
-            printTrees(bindings, lineBreak())
-          }
-          this += lineBreak()
-          printTree(expansion)
+          printStats(bindings, expansion)
         }
         this += lineBreak() += "}"
 
@@ -400,6 +391,30 @@ 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]) = {
+        this += lineBreak()
+        // 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(_, _) => this += lineBreak()
+          case Term.Inlined(_, _, _) => this += lineBreak()
+          case _ =>
+        }
+      }
+      def printSeparated(list: List[Tree]): Unit = list match {
+        case Nil =>
+          printTree(expr)
+        case x :: xs =>
+          printTree(x)
+          printSeparator(xs)
+          printSeparated(xs)
+      }
+
+      this += lineBreak()
+      printSeparated(stats)
+    }
+
     def printTrees(trees: List[Tree], sep: String): Buffer = {
       def printSeparated(list: List[Tree]): Unit = list match {
         case Nil =>
@@ -603,14 +618,11 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       }
       this += " =>"
       indented {
-        this += lineBreak()
         body match {
           case Term.Block(stats, expr) =>
-            printTrees(stats, lineBreak())
-            if (stats.nonEmpty)
-              this += lineBreak()
-            printTree(expr)
+            printStats(stats, expr)
           case body =>
+            this += lineBreak()
             printTree(body)
         }
       }

tests/pos/simpleDoWhile.decompiled

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

tests/pos/simpleSingleton.decompiled

@@ -11,4 +11,4 @@ class Foo() {
 }
 object Foo {
   object Bar
-}
+}

tests/pos/simpleWhile.decompiled

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

tests/run-with-compiler/i3876-d.check

@@ -1,6 +1,7 @@
 6
 {
   val x$1: scala.Int = 3
+
   { // inlined
     x$1.+(x$1)
   }

tests/run-with-compiler/i4044b.check

@@ -1,5 +1,5 @@
 {
   var x: scala.Int = 4
-  x = 3
+  x = 3;
   x
 }

tests/run-with-compiler/quote-show-blocks-raw.check

@@ -1,11 +1,15 @@
 {
   scala.Predef.println(1)
+
   {
     scala.Predef.println(2)
+
     {
       scala.Predef.println(3)
+
       {
         scala.Predef.println(4)
+
         {
           scala.Predef.println(5)
           ()

tests/run/puzzle.decompiled

@@ -8,4 +8,4 @@ object Test {
     val y: scala.Float = scala.Long.long2float(z)
     ()
   }
-}
+}

tests/run/simpleClass.decompiled

@@ -12,4 +12,4 @@ package foo {
 /** Decompiled from out/runTestFromTasty/run/simpleClass/foo/B.class */
 package foo {
   class B() extends foo.A()
-}
+}