Move ThicketTransformer to s.t.n.transform

It seems generally useful enough to move it out of
the async utilities. I've also added a unit test.

Author: retronym

src/compiler/scala/tools/nsc/transform/TypingTransformers.scala

@@ -13,6 +13,9 @@
 package scala.tools.nsc
 package transform
 
+import scala.collection.mutable
+
+
 /** A base class for transforms.
  *  A transform contains a compiler phase which applies a tree transformer.
  */
@@ -56,5 +59,56 @@ trait TypingTransformers {
     }
     def transformAtOwner(owner: Symbol, tree: Tree): Tree = atOwner(tree, owner) { transform(tree) }
   }
+
+  private object ThicketAttachment
+  /** A base class for typing transformers that need to perform "thicket expansion". A thicket is the output of a
+   *  transformation that is flattened into the enclosing block.
+   */
+  abstract class ThicketTransformer(initLocalTyper: analyzer.Typer) extends TypingTransformer(initLocalTyper) {
+    private def expandThicket(t: Tree): List[Tree] = t match {
+      case Block(stats, expr) if t.attachments.containsElement(ThicketAttachment) =>
+        stats :+ expr
+      case _ => t :: Nil
+    }
+
+    def apply(tree: Tree): List[Tree] = expandThicket(transform(tree))
+
+    protected def Thicket(stats: List[Tree], expr: Tree): Tree = {
+      Block(stats, expr).updateAttachment(ThicketAttachment)
+    }
+    protected def Thicket(block: Block): Tree = {
+      block.updateAttachment(ThicketAttachment)
+    }
+
+    override def transform(tree: Tree): Tree = tree match {
+      case Block(stats, expr) =>
+        val transformedStats = transformTrees(stats)
+        val transformedExpr = transform(expr)
+        if ((stats eq transformedStats) && (expr eq transformedExpr)) tree
+        else {
+          val expanded = new mutable.ListBuffer[Tree]
+          def expandStats(): Unit = transformedStats.foreach {
+            case EmptyTree =>
+            case blk @ Block(stats, expr) if blk.attachments.containsElement(ThicketAttachment) =>
+              stats.foreach { s => if (s != EmptyTree) expanded += s }
+              if (expr != EmptyTree) expanded += expr
+            case t =>
+              expanded += t
+          }
+          def expandExpr(): Tree = transformedExpr match {
+            case blk @ Block(stats, expr) if blk.attachments.containsElement(ThicketAttachment) =>
+              stats.foreach { s => if (s != EmptyTree) expanded += s }
+              expr
+            case t =>
+              t
+          }
+          expandStats()
+          val expr1 = expandExpr()
+          treeCopy.Block(tree, expanded.toList, expr1)
+        }
+      case _ =>
+        super.transform(tree)
+    }
+  }
 }
 

src/compiler/scala/tools/nsc/transform/async/TransformUtils.scala

@@ -89,7 +89,7 @@ private[async] trait TransformUtils extends AsyncTransformStates {
   }
 
   private object ThicketAttachment
-  class ThicketTransformer(initLocalTyper: analyzer.Typer) extends TypingTransformer(initLocalTyper) {
+  abstract class ThicketTransformer(initLocalTyper: analyzer.Typer) extends TypingTransformer(initLocalTyper) {
     private def expandThicket(t: Tree): List[Tree] = t match {
       case Block(stats, expr) if t.attachments.containsElement(ThicketAttachment) =>
         stats :+ expr

test/junit/scala/tools/nsc/transform/ThicketTransformerTest.scala

@@ -0,0 +1,82 @@
+package scala.tools.nsc.transform
+
+import org.junit.Assert.assertSame
+import org.junit.{Assert, Test}
+
+import scala.tools.nsc.reporters.StoreReporter
+
+class ThicketTransformerTest {
+  @Test def thicketExpansion(): Unit = {
+    val g = new scala.tools.nsc.Global(new StoreReporter)
+    g.settings.usejavacp.value = true
+    new g.Run
+    import g._
+    object testTransformers extends TypingTransformers {
+      val global: g.type = g
+      val dummyUnit = newCompilationUnit("")
+
+      object testTransformer extends ThicketTransformer(newRootLocalTyper(dummyUnit)) {
+        override def transform(tree: Tree): Tree = tree match {
+          case Literal(Constant(s: String)) if (s.toLowerCase() != s) => Literal(Constant(s.toLowerCase()))
+          case Literal(Constant(s: String)) => s.toList.filterNot(_ == '-') match {
+            case Nil => Thicket(Nil, EmptyTree)
+            case a :: Nil => tree
+            case as =>
+              Thicket(Block(as.map(c => Literal(Constant(c.toString)).setType(definitions.StringTpe)): _*))
+          }
+          case t => super.transform(t)
+        }
+      }
+    }
+    def t(t: Tree): Tree = testTransformers.testTransformer.transform(t)
+    def assertTreeEquals(expected: Tree, actual: Tree) = Assert.assertEquals(expected.toString, actual.toString)
+
+    def s(s: String) = Literal(Constant(s))
+    def i(i: Int) = Literal(Constant(i))
+
+    locally {
+      val noTransform = Block(s("a") :: Nil, s("b"))
+      assertSame(noTransform, t(noTransform))
+    }
+
+    locally {
+      val noTransform = Block(s("a") :: s("b") :: Nil, s("c"))
+      assertSame(noTransform, t(noTransform))
+    }
+
+    locally {
+      val transformStats = Block(s("ab") :: i(1) :: s("cd") :: Nil, s("e"))
+      assertTreeEquals(Block(s("a") :: s("b") :: i(1) :: s("c") :: s("d") :: Nil, s("e")), t(transformStats))
+    }
+
+    locally {
+      val transformStats = Block(s("ab") :: s("cd") :: Nil, s("e"))
+      assertTreeEquals(Block(s("a") :: s("b") :: s("c") :: s("d") :: Nil, s("e")), t(transformStats))
+    }
+
+    locally {
+      val transformExpr = Block(s("a") :: s("b") :: Nil, s("cd"))
+      assertTreeEquals(Block(s("a") :: s("b") :: s("c") :: Nil, s("d")), t(transformExpr))
+    }
+
+    locally {
+      val transformStatsExpr = Block(s("ab") :: s("cd") :: Nil, s("ef"))
+      assertTreeEquals(Block(s("a") :: s("b") :: s("c") :: s("d") :: s("e") :: Nil, s("f")), t(transformStatsExpr))
+    }
+
+    locally {
+      val transformStatsExpr = Block(s("A") :: s("B") :: Nil, s("cd"))
+      assertTreeEquals(Block(s("a") :: s("b") :: s("c") :: Nil, s("d")), t(transformStatsExpr))
+    }
+
+    locally {
+      val transformStatsExpr = Block(s("A") :: s("B") :: Nil, s("C"))
+      assertTreeEquals(Block(s("a") :: s("b") :: Nil, s("c")), t(transformStatsExpr))
+    }
+
+    locally {
+      val transformStatsExpr = Block(s("-") :: Nil, s("a"))
+      assertTreeEquals(Block(Nil, s("a")), t(transformStatsExpr))
+    }
+  }
+}