Remove DoWhile from tasty-reflect.

sjrd · sjrd · commit 2acfbf83d816 · 2018-09-21T20:55:37.000+02:00
This avoids the awkward situation where `WhileDo` needs to be
tested before `While` for it to meaningful, or suffering some more
performance hit by rejecting `do-while`-like stuff in the `While`
deconstructor.

It will probably also simplify most usage patterns of the
tasty-reflect API, since users will only have to worry about one
kind of loop.

The decompiler takes it upon itself to deconstruct `While` loops
that look like the product of `do..while` to print a nice
decompilation output.
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
@@ -378,14 +378,6 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
         case _ => None
       }
     }
-
-    object DoWhile extends DoWhileExtractor {
-      def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term)] = x match {
-        case Trees.WhileDo(Trees.Block(Trees.Block(Nil, body) :: Nil, Trees.Block(Nil, cond)), Trees.Literal(Constants.Constant(()))) =>
-          Some((body, cond))
-        case _ => None
-      }
-    }
   }
 
   def termAsParent(term: Term): Parent = term
diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala
@@ -298,12 +298,6 @@ trait TreeOps extends TastyCore {
       /** Extractor for while loops. Matches `while (<cond>) <body>` and returns (<cond>, <body>) */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)]
     }
-
-    val DoWhile: DoWhileExtractor
-    abstract class DoWhileExtractor {
-      /** Extractor for do while loops. Matches `do <body> while (<cond>)` and returns (<body>, <cond>) */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)]
-    }
   }
 
   implicit def termAsParent(term: Term): Parent
diff --git a/library/src/scala/tasty/util/ShowSourceCode.scala b/library/src/scala/tasty/util/ShowSourceCode.scala
@@ -227,15 +227,17 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
             this
         }
 
-      case Term.DoWhile(body, cond) => // DoWhile must come before While
-        this += "do "
-        printTree(body) += " while "
-        inParens(printTree(cond))
-
       case Term.While(cond, body) =>
-        this += "while "
-        inParens(printTree(cond)) += " "
-        printTree(body)
+        (cond, body) match {
+          case (Term.Block(Term.Block(Nil, body1) :: Nil, Term.Block(Nil, cond1)), Term.Literal(Constant.Unit())) =>
+            this += "do "
+            printTree(body1) += " while "
+            inParens(printTree(cond1))
+          case _ =>
+            this += "while "
+            inParens(printTree(cond)) += " "
+            printTree(body)
+        }
 
       case IsDefDef(ddef @ DefDef(name, targs, argss, tpt, rhs)) =>
         printDefAnnotations(ddef)

Original file line number	Diff line number	Diff line change
`@@ -378,14 +378,6 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He`
`378`	`378`	`case _ => None`
`379`	`379`	`}`
`380`	`380`	`}`
`381`		`-`
`382`		`- object DoWhile extends DoWhileExtractor {`
`383`		`- def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term)] = x match {`
`384`		`- case Trees.WhileDo(Trees.Block(Trees.Block(Nil, body) :: Nil, Trees.Block(Nil, cond)), Trees.Literal(Constants.Constant(()))) =>`
`385`		`- Some((body, cond))`
`386`		`- case _ => None`
`387`		`- }`
`388`		`- }`
`389`	`381`	`}`
`390`	`382`
`391`	`383`	`def termAsParent(term: Term): Parent = term`
Original file line number	Diff line number	Diff line change
`@@ -298,12 +298,6 @@ trait TreeOps extends TastyCore {`
`298`	`298`	/** Extractor for while loops. Matches `while (<cond>) <body>` and returns (<cond>, <body>) */
`299`	`299`	`def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)]`
`300`	`300`	`}`
`301`		`-`
`302`		`- val DoWhile: DoWhileExtractor`
`303`		`- abstract class DoWhileExtractor {`
`304`		- /** Extractor for do while loops. Matches `do <body> while (<cond>)` and returns (<body>, <cond>) */
`305`		`- def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)]`
`306`		`- }`
`307`	`301`	`}`
`308`	`302`
`309`	`303`	`implicit def termAsParent(term: Term): Parent`