From 3bc78930d18d751a75ff6908f5dd166935dc3ffe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Sat, 15 Sep 2018 21:52:27 +0200
Subject: [PATCH 1/2] Promote `WhileDo` loops to typed trees.

They remain as such, without desugaring, until the back-end. We
also use them to desugar `DoWhile` loops, instead of label-defs:

  do { body } while (cond)

is now desugared as

  while { { body }; { cond } } ()

the inner blocks protecting the respective scopes of `body` and
`cond` from each other.

This is the second step towards getting rid of label-defs.
---
 .../backend/jvm/DottyBackendInterface.scala   |  7 ++
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 19 +----
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 15 ++++
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  6 ++
 compiler/src/dotty/tools/dotc/ast/untpd.scala | 10 +--
 .../tools/dotc/core/tasty/TastyFormat.scala   | 83 ++++++++++---------
 .../tools/dotc/core/tasty/TreePickler.scala   |  6 ++
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  4 +
 .../tools/dotc/printing/RefinedPrinter.scala  |  4 +-
 .../tools/dotc/tastyreflect/TreeOpsImpl.scala | 19 ++---
 .../tools/dotc/transform/MegaPhase.scala      | 31 ++++++-
 .../dotty/tools/dotc/typer/TypeAssigner.scala |  3 +
 .../src/dotty/tools/dotc/typer/Typer.scala    |  7 ++
 .../src/scala/tasty/util/ShowExtractors.scala |  2 +
 .../src/scala/tasty/util/ShowSourceCode.scala | 10 +--
 scala-backend                                 |  2 +-
 .../quote-inline-function.check               | 10 ++-
 17 files changed, 145 insertions(+), 93 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index fb5fb35e49e9..8114a00f80a9 100644
--- a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -63,6 +63,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   type Throw           = tpd.Apply
   type Labeled         = tpd.Labeled
   type Return          = tpd.Return
+  type WhileDo         = tpd.WhileDo
   type Block           = tpd.Block
   type Typed           = tpd.Typed
   type Match           = tpd.Match
@@ -196,6 +197,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   implicit val ThrowTag: ClassTag[Throw] = ClassTag[Throw](classOf[Throw])
   implicit val LabeledTag: ClassTag[Labeled] = ClassTag[Labeled](classOf[Labeled])
   implicit val ReturnTag: ClassTag[Return] = ClassTag[Return](classOf[Return])
+  implicit val WhileDoTag: ClassTag[WhileDo] = ClassTag[WhileDo](classOf[WhileDo])
   implicit val LiteralTag: ClassTag[Literal] = ClassTag[Literal](classOf[Literal])
   implicit val BlockTag: ClassTag[Block] = ClassTag[Block](classOf[Block])
   implicit val TypedTag: ClassTag[Typed] = ClassTag[Typed](classOf[Typed])
@@ -1088,6 +1090,11 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def _2: Symbol = if (field.from.symbol.isLabel) field.from.symbol else NoSymbol
   }
 
+  object WhileDo extends WhileDoDeconstructor {
+    def _1: Tree = field.cond
+    def _2: Tree = field.body
+  }
+
   object Ident extends IdentDeconstructor {
     def get = field.name
   }
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 1104ecb9230e..b22e31492156 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -927,13 +927,6 @@ object desugar {
   /** Main desugaring method */
   def apply(tree: Tree)(implicit ctx: Context): Tree = {
 
-    /**    { label def lname(): Unit = rhs; call }
-     */
-    def labelDefAndCall(lname: TermName, rhs: Tree, call: Tree) = {
-      val ldef = DefDef(lname, Nil, ListOfNil, TypeTree(defn.UnitType), rhs).withFlags(Label | Synthetic)
-      Block(ldef, call)
-    }
-
     /** Create tree for for-comprehension `<for (enums) do body>` or
      *   `<for (enums) yield body>` where mapName and flatMapName are chosen
      *  corresponding to whether this is a for-do or a for-yield.
@@ -1158,16 +1151,10 @@ object desugar {
       case PrefixOp(op, t) =>
         val nspace = if (ctx.mode.is(Mode.Type)) tpnme else nme
         Select(t, nspace.UNARY_PREFIX ++ op.name)
-      case WhileDo(cond, body) =>
-        // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
-        val call = Apply(Ident(nme.WHILE_PREFIX), Nil).withPos(tree.pos)
-        val rhs = If(cond, Block(body, call), unitLiteral)
-        labelDefAndCall(nme.WHILE_PREFIX, rhs, call)
       case DoWhile(body, cond) =>
-        // { label def doWhile$(): Unit = { body; if (cond) doWhile$() } ; doWhile$() }
-        val call = Apply(Ident(nme.DO_WHILE_PREFIX), Nil).withPos(tree.pos)
-        val rhs = Block(body, If(cond, call, unitLiteral))
-        labelDefAndCall(nme.DO_WHILE_PREFIX, rhs, call)
+        // while ({ { body }; { cond } }) { () }
+        // the inner blocks are there to protect the scopes of body and cond from each other
+        WhileDo(Block(Block(Nil, body), Block(Nil, cond)), Literal(Constant(())))
       case ForDo(enums, body) =>
         makeFor(nme.foreach, nme.foreach, enums, body) orElse tree
       case ForYield(enums, body) =>
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index bc45df6e382d..f0017abb5f26 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -549,6 +549,12 @@ object Trees {
     type ThisTree[-T >: Untyped] = Return[T]
   }
 
+  /** while (cond) { body } */
+  case class WhileDo[-T >: Untyped] private[ast] (cond: Tree[T], body: Tree[T])
+    extends TermTree[T] {
+    type ThisTree[-T >: Untyped] = WhileDo[T]
+  }
+
   /** try block catch handler finally finalizer
    *
    *  Note: if the handler is a case block CASES of the form
@@ -911,6 +917,7 @@ object Trees {
     type CaseDef = Trees.CaseDef[T]
     type Labeled = Trees.Labeled[T]
     type Return = Trees.Return[T]
+    type WhileDo = Trees.WhileDo[T]
     type Try = Trees.Try[T]
     type SeqLiteral = Trees.SeqLiteral[T]
     type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
@@ -1067,6 +1074,10 @@ object Trees {
         case tree: Return if (expr eq tree.expr) && (from eq tree.from) => tree
         case _ => finalize(tree, untpd.Return(expr, from))
       }
+      def WhileDo(tree: Tree)(cond: Tree, body: Tree)(implicit ctx: Context): WhileDo = tree match {
+        case tree: WhileDo if (cond eq tree.cond) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.WhileDo(cond, body))
+      }
       def Try(tree: Tree)(expr: Tree, cases: List[CaseDef], finalizer: Tree)(implicit ctx: Context): Try = tree match {
         case tree: Try if (expr eq tree.expr) && (cases eq tree.cases) && (finalizer eq tree.finalizer) => tree
         case _ => finalize(tree, untpd.Try(expr, cases, finalizer))
@@ -1245,6 +1256,8 @@ object Trees {
             cpy.Labeled(tree)(transformSub(bind), transform(expr))
           case Return(expr, from) =>
             cpy.Return(tree)(transform(expr), transformSub(from))
+          case WhileDo(cond, body) =>
+            cpy.WhileDo(tree)(transform(cond), transform(body))
           case Try(block, cases, finalizer) =>
             cpy.Try(tree)(transform(block), transformSub(cases), transform(finalizer))
           case SeqLiteral(elems, elemtpt) =>
@@ -1381,6 +1394,8 @@ object Trees {
             this(this(x, bind), expr)
           case Return(expr, from) =>
             this(this(x, expr), from)
+          case WhileDo(cond, body) =>
+            this(this(x, cond), body)
           case Try(block, handler, finalizer) =>
             this(this(this(x, block), handler), finalizer)
           case SeqLiteral(elems, elemtpt) =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index e22537d8e88a..1c69062a1430 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -129,6 +129,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Return(expr: Tree, from: Tree)(implicit ctx: Context): Return =
     ta.assignType(untpd.Return(expr, from))
 
+  def WhileDo(cond: Tree, body: Tree)(implicit ctx: Context): WhileDo =
+    ta.assignType(untpd.WhileDo(cond, body))
+
   def Try(block: Tree, cases: List[CaseDef], finalizer: Tree)(implicit ctx: Context): Try =
     ta.assignType(untpd.Try(block, cases, finalizer), block, cases)
 
@@ -609,6 +612,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     override def Return(tree: Tree)(expr: Tree, from: Tree)(implicit ctx: Context): Return =
       ta.assignType(untpd.cpy.Return(tree)(expr, from))
 
+    override def WhileDo(tree: Tree)(cond: Tree, body: Tree)(implicit ctx: Context): WhileDo =
+      ta.assignType(untpd.cpy.WhileDo(tree)(cond, body))
+
     override def Try(tree: Tree)(expr: Tree, cases: List[CaseDef], finalizer: Tree)(implicit ctx: Context): Try = {
       val tree1 = untpd.cpy.Try(tree)(expr, cases, finalizer)
       tree match {
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index c11cf439fa0e..53e637760438 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -85,7 +85,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   }
   case class Throw(expr: Tree) extends TermTree
   case class Quote(expr: Tree) extends TermTree
-  case class WhileDo(cond: Tree, body: Tree) extends TermTree
   case class DoWhile(body: Tree, cond: Tree) extends TermTree
   case class ForYield(enums: List[Tree], expr: Tree) extends TermTree
   case class ForDo(enums: List[Tree], body: Tree) extends TermTree
@@ -280,6 +279,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def CaseDef(pat: Tree, guard: Tree, body: Tree): CaseDef = new CaseDef(pat, guard, body)
   def Labeled(bind: Bind, expr: Tree): Labeled = new Labeled(bind, expr)
   def Return(expr: Tree, from: Tree): Return = new Return(expr, from)
+  def WhileDo(cond: Tree, body: Tree): WhileDo = new WhileDo(cond, body)
   def Try(expr: Tree, cases: List[CaseDef], finalizer: Tree): Try = new Try(expr, cases, finalizer)
   def SeqLiteral(elems: List[Tree], elemtpt: Tree): SeqLiteral = new SeqLiteral(elems, elemtpt)
   def JavaSeqLiteral(elems: List[Tree], elemtpt: Tree): JavaSeqLiteral = new JavaSeqLiteral(elems, elemtpt)
@@ -470,10 +470,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: Quote if expr eq tree.expr => tree
       case _ => finalize(tree, untpd.Quote(expr))
     }
-    def WhileDo(tree: Tree)(cond: Tree, body: Tree) = tree match {
-      case tree: WhileDo if (cond eq tree.cond) && (body eq tree.body) => tree
-      case _ => finalize(tree, untpd.WhileDo(cond, body))
-    }
     def DoWhile(tree: Tree)(body: Tree, cond: Tree) = tree match {
       case tree: DoWhile if (body eq tree.body) && (cond eq tree.cond) => tree
       case _ => finalize(tree, untpd.DoWhile(body, cond))
@@ -534,8 +530,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.Throw(tree)(transform(expr))
       case Quote(expr) =>
         cpy.Quote(tree)(transform(expr))
-      case WhileDo(cond, body) =>
-        cpy.WhileDo(tree)(transform(cond), transform(body))
       case DoWhile(body, cond) =>
         cpy.DoWhile(tree)(transform(body), transform(cond))
       case ForYield(enums, expr) =>
@@ -585,8 +579,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(x, expr)
       case Quote(expr) =>
         this(x, expr)
-      case WhileDo(cond, body) =>
-        this(this(x, cond), body)
       case DoWhile(body, cond) =>
         this(this(x, body), cond)
       case ForYield(enums, expr) =>
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
index a27c9bdd49eb..5d45473608f8 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -91,6 +91,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   MATCH          Length sel_Term CaseDef*
                   TRY            Length expr_Term CaseDef* finalizer_Term?
                   RETURN         Length meth_ASTRef expr_Term?
+                  WHILE          Length cond_Term body_Term
                   REPEATED       Length elem_Type elem_Term*
                   SELECTouter    Length levels_Nat qual_Term underlying_Type
                   BIND           Length boundName_NameRef patType_Type pat_Term
@@ -245,7 +246,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion = 10
+  val MajorVersion = 11
   val MinorVersion = 0
 
   /** Tags used to serialize names */
@@ -392,48 +393,49 @@ object TastyFormat {
   final val LAMBDA = 142
   final val MATCH = 143
   final val RETURN = 144
-  final val TRY = 145
-  final val INLINED = 146
-  final val SELECTouter = 147
-  final val REPEATED = 148
-  final val BIND = 149
-  final val ALTERNATIVE = 150
-  final val UNAPPLY = 151
-  final val ANNOTATEDtype = 152
-  final val ANNOTATEDtpt = 153
-  final val CASEDEF = 154
-  final val TEMPLATE = 155
-  final val SUPER = 156
-  final val SUPERtype = 157
-  final val REFINEDtype = 158
-  final val REFINEDtpt = 159
-  final val APPLIEDtype = 160
-  final val APPLIEDtpt = 161
-  final val TYPEBOUNDS = 162
-  final val TYPEBOUNDStpt = 163
-  final val ANDtype = 164
-  final val ANDtpt = 165
-  final val ORtype = 166
-  final val ORtpt = 167
-  final val POLYtype = 168
-  final val TYPELAMBDAtype = 169
-  final val LAMBDAtpt = 170
-  final val PARAMtype = 171
-  final val ANNOTATION = 172
-  final val TERMREFin = 173
-  final val TYPEREFin = 174
-  final val OBJECTDEF = 175
-
-  // In binary: 101100EI
+  final val WHILE = 145
+  final val TRY = 146
+  final val INLINED = 147
+  final val SELECTouter = 148
+  final val REPEATED = 149
+  final val BIND = 150
+  final val ALTERNATIVE = 151
+  final val UNAPPLY = 152
+  final val ANNOTATEDtype = 153
+  final val ANNOTATEDtpt = 154
+  final val CASEDEF = 155
+  final val TEMPLATE = 156
+  final val SUPER = 157
+  final val SUPERtype = 158
+  final val REFINEDtype = 159
+  final val REFINEDtpt = 160
+  final val APPLIEDtype = 161
+  final val APPLIEDtpt = 162
+  final val TYPEBOUNDS = 163
+  final val TYPEBOUNDStpt = 164
+  final val ANDtype = 165
+  final val ANDtpt = 166
+  final val ORtype = 167
+  final val ORtpt = 168
+  final val POLYtype = 169
+  final val TYPELAMBDAtype = 170
+  final val LAMBDAtpt = 171
+  final val PARAMtype = 172
+  final val ANNOTATION = 173
+  final val TERMREFin = 174
+  final val TYPEREFin = 175
+  final val OBJECTDEF = 176
+
+  // In binary: 101101EI
   // I = implicit method type
   // E = erased method type
-  final val METHODtype = 176
-  final val IMPLICITMETHODtype = 177
-  final val ERASEDMETHODtype = 178
-  final val ERASEDIMPLICITMETHODtype = 179
+  final val METHODtype = 180
+  final val IMPLICITMETHODtype = 181
+  final val ERASEDMETHODtype = 182
+  final val ERASEDIMPLICITMETHODtype = 183
 
-  final val MATCHtype = 180
-  final val MATCHtpt = 181
+  final val MATCHtype = 190
+  final val MATCHtpt = 191
 
   final val UNTYPEDSPLICE = 199
 
@@ -607,6 +609,7 @@ object TastyFormat {
     case LAMBDA => "LAMBDA"
     case MATCH => "MATCH"
     case RETURN => "RETURN"
+    case WHILE => "WHILE"
     case INLINED => "INLINED"
     case SELECTouter => "SELECTouter"
     case TRY => "TRY"
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 240ac4d2ff24..edd943c2f71e 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -436,6 +436,9 @@ class TreePickler(pickler: TastyPickler) {
         case Return(expr, from) =>
           writeByte(RETURN)
           withLength { pickleSymRef(from.symbol); pickleTreeUnlessEmpty(expr) }
+        case WhileDo(cond, body) =>
+          writeByte(WHILE)
+          withLength { pickleTree(cond); pickleTree(body) }
         case Try(block, cases, finalizer) =>
           writeByte(TRY)
           withLength { pickleTree(block); cases.foreach(pickleTree); pickleTreeUnlessEmpty(finalizer) }
@@ -796,6 +799,9 @@ class TreePickler(pickler: TastyPickler) {
       case Return(expr, from) =>
         writeByte(RETURN)
         withLength { pickleDummyRef(); pickleUnlessEmpty(expr) }
+      case WhileDo(cond, body) =>
+        writeByte(WHILE)
+        withLength { pickleUntyped(cond); pickleUntyped(body) }
       case Try(block, cases, finalizer) =>
         writeByte(TRY)
         withLength { pickleUntyped(block); cases.foreach(pickleUntyped); pickleUnlessEmpty(finalizer) }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index b768d59086fc..7012c26ed5e4 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1080,6 +1080,8 @@ class TreeUnpickler(reader: TastyReader,
               val from = readSymRef()
               val expr = ifBefore(end)(readTerm(), EmptyTree)
               Return(expr, Ident(from.termRef))
+            case WHILE =>
+              WhileDo(readTerm(), readTerm())
             case TRY =>
               Try(readTerm(), readCases(end), ifBefore(end)(readTerm(), EmptyTree))
             case SELECTouter =>
@@ -1331,6 +1333,8 @@ class TreeUnpickler(reader: TastyReader,
             readNat()
             val expr = ifBefore(end)(readUntyped(), untpd.EmptyTree)
             untpd.Return(expr, untpd.EmptyTree)
+          case WHILE =>
+            untpd.WhileDo(readUntyped(), readUntyped())
           case TRY =>
             untpd.Try(readUntyped(), readCases(end), ifBefore(end)(readUntyped(), untpd.EmptyTree))
           case BIND =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index ecf85a649c88..5227fca1f632 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -381,6 +381,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           changePrec(GlobalPrec) { keywordStr("return[") ~ toText(sym.name) ~ keywordStr("]") ~ optText(expr)(" " ~ _) }
         else
           changePrec(GlobalPrec) { keywordStr("return") ~ optText(expr)(" " ~ _) }
+      case WhileDo(cond, body) =>
+        changePrec(GlobalPrec) { keywordStr("while ") ~ toText(cond) ~ keywordStr(" do ") ~ toText(body) }
       case Try(expr, cases, finalizer) =>
         changePrec(GlobalPrec) {
           keywordStr("try ") ~ toText(expr) ~ optText(cases)(keywordStr(" catch ") ~ _) ~ optText(finalizer)(keywordStr(" finally ") ~ _)
@@ -524,8 +526,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         "(" ~ toTextGlobal(t) ~ ")"
       case Tuple(ts) =>
         "(" ~ toTextGlobal(ts, ", ") ~ ")"
-      case WhileDo(cond, body) =>
-        changePrec(GlobalPrec) { keywordStr("while ") ~ toText(cond) ~ keywordStr(" do ") ~ toText(body) }
       case DoWhile(cond, body) =>
         changePrec(GlobalPrec) { keywordStr("do ") ~ toText(body) ~ keywordStr(" while ") ~ toText(cond) }
       case ForYield(enums, expr) =>
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
index be059ded4748..b5f02eae7c15 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
@@ -278,7 +278,6 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
 
     object Block extends BlockExtractor {
       def unapply(x: Term)(implicit ctx: Context): Option[(List[Statement], Term)] = normalizedLoops(x) match {
-        case Trees.Block(_, expr) if expr.symbol.is(Flags.Label) => None // while or doWhile loops
         case Trees.Block(stats, expr) => Some((stats, expr))
         case _ => None
       }
@@ -305,10 +304,10 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
         case _ => tree
       }
 
-      /** If it is the second statement of a loop or a closure. See: `normalizedLoops` */
+      /** If it is the second statement of a closure. See: `normalizedLoops` */
       private def needsNormalization(tree: tpd.Tree)(implicit ctx: Context): Boolean = tree match {
         case _: tpd.Closure => true
-        case _ => tree.symbol.is(Flags.Label)
+        case _ => false
       }
     }
 
@@ -375,26 +374,18 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
 
     object While extends WhileExtractor {
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term)] = x match {
-        case Trees.Block((ddef: tpd.DefDef) :: Nil, expr) if expr.symbol.is(Flags.Label) && expr.symbol.name == nme.WHILE_PREFIX =>
-          val Trees.If(cond, Trees.Block(bodyStats, _), _) = ddef.rhs
-          Some((cond, loopBody(bodyStats)))
+        case x: tpd.WhileDo => Some((x.cond, x.body))
         case _ => None
       }
     }
 
     object DoWhile extends DoWhileExtractor {
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term)] = x match {
-        case Trees.Block((ddef: tpd.DefDef) :: Nil, expr) if expr.symbol.is(Flags.Label) && expr.symbol.name == nme.DO_WHILE_PREFIX =>
-          val Trees.Block(bodyStats, Trees.If(cond, _, _)) = ddef.rhs
-          Some((loopBody(bodyStats), cond))
+        case Trees.WhileDo(Trees.Block(Trees.Block(Nil, body) :: Nil, Trees.Block(Nil, cond)), Trees.Literal(Constants.Constant(()))) =>
+          Some((body, cond))
         case _ => None
       }
     }
-
-    private def loopBody(stats: List[tpd.Tree])(implicit ctx: Context): tpd.Tree = stats match {
-      case body :: Nil => body
-      case stats => tpd.Block(stats.init, stats.last)
-    }
   }
 
   def termAsParent(term: Term): Parent = term
diff --git a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
index e361081c82aa..a834ea622b6e 100644
--- a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
@@ -68,6 +68,7 @@ object MegaPhase {
     def prepareForCaseDef(tree: CaseDef)(implicit ctx: Context) = ctx
     def prepareForLabeled(tree: Labeled)(implicit ctx: Context) = ctx
     def prepareForReturn(tree: Return)(implicit ctx: Context) = ctx
+    def prepareForWhileDo(tree: WhileDo)(implicit ctx: Context) = ctx
     def prepareForTry(tree: Try)(implicit ctx: Context) = ctx
     def prepareForSeqLiteral(tree: SeqLiteral)(implicit ctx: Context) = ctx
     def prepareForInlined(tree: Inlined)(implicit ctx: Context) = ctx
@@ -101,6 +102,7 @@ object MegaPhase {
     def transformCaseDef(tree: CaseDef)(implicit ctx: Context): Tree = tree
     def transformLabeled(tree: Labeled)(implicit ctx: Context): Tree = tree
     def transformReturn(tree: Return)(implicit ctx: Context): Tree = tree
+    def transformWhileDo(tree: WhileDo)(implicit ctx: Context): Tree = tree
     def transformTry(tree: Try)(implicit ctx: Context): Tree = tree
     def transformSeqLiteral(tree: SeqLiteral)(implicit ctx: Context): Tree = tree
     def transformInlined(tree: Inlined)(implicit ctx: Context): Tree = tree
@@ -202,6 +204,7 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
           case tree: Try => goTry(tree, start)
           case tree: Inlined => goInlined(tree, start)
           case tree: Return => goReturn(tree, start)
+          case tree: WhileDo => goWhileDo(tree, start)
           case tree: Alternative => goAlternative(tree, start)
           case tree => goOther(tree, start)
         }
@@ -376,6 +379,11 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
         goReturn(cpy.Return(tree)(expr, tree.from), start)
           // don't transform `tree.from`, as this is not a normal ident, but
           // a pointer to the enclosing method.
+      case tree: WhileDo =>
+        implicit val ctx = prepWhileDo(tree, start)(outerCtx)
+        val cond = transformTree(tree.cond, start)
+        val body = transformTree(tree.body, start)
+        goWhileDo(cpy.WhileDo(tree)(cond, body), start)
       case tree: Alternative =>
         implicit val ctx = prepAlternative(tree, start)(outerCtx)
         val trees = transformTrees(tree.trees, start)
@@ -493,8 +501,12 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
   private val nxMatchTransPhase = init("transformMatch")
   private val nxCaseDefPrepPhase = init("prepareForCaseDef")
   private val nxCaseDefTransPhase = init("transformCaseDef")
+  private val nxLabeledPrepPhase = init("prepareForLabeled")
+  private val nxLabeledTransPhase = init("transformLabeled")
   private val nxReturnPrepPhase = init("prepareForReturn")
   private val nxReturnTransPhase = init("transformReturn")
+  private val nxWhileDoPrepPhase = init("prepareForWhileDo")
+  private val nxWhileDoTransPhase = init("transformWhileDo")
   private val nxTryPrepPhase = init("prepareForTry")
   private val nxTryTransPhase = init("transformTry")
   private val nxSeqLiteralPrepPhase = init("prepareForSeqLiteral")
@@ -754,13 +766,13 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
   }
 
   def prepLabeled(tree: Labeled, start: Int)(implicit ctx: Context): Context = {
-    val phase = nxReturnPrepPhase(start)
+    val phase = nxLabeledPrepPhase(start)
     if (phase == null) ctx
     else prepLabeled(tree, phase.idxInGroup + 1)(phase.prepareForLabeled(tree))
   }
 
   def goLabeled(tree: Labeled, start: Int)(implicit ctx: Context): Tree = {
-    val phase = nxReturnTransPhase(start)
+    val phase = nxLabeledTransPhase(start)
     if (phase == null) tree
     else phase.transformLabeled(tree)(ctx) match {
       case tree1: Labeled => goLabeled(tree1, phase.idxInGroup + 1)
@@ -783,6 +795,21 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
     }
   }
 
+  def prepWhileDo(tree: WhileDo, start: Int)(implicit ctx: Context): Context = {
+    val phase = nxWhileDoPrepPhase(start)
+    if (phase == null) ctx
+    else prepWhileDo(tree, phase.idxInGroup + 1)(phase.prepareForWhileDo(tree))
+  }
+
+  def goWhileDo(tree: WhileDo, start: Int)(implicit ctx: Context): Tree = {
+    val phase = nxWhileDoTransPhase(start)
+    if (phase == null) tree
+    else phase.transformWhileDo(tree)(ctx) match {
+      case tree1: WhileDo => goWhileDo(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
   def prepTry(tree: Try, start: Int)(implicit ctx: Context): Context = {
     val phase = nxTryPrepPhase(start)
     if (phase == null) ctx
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 9bad43a3d740..06ddce362853 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -486,6 +486,9 @@ trait TypeAssigner {
   def assignType(tree: untpd.Return)(implicit ctx: Context) =
     tree.withType(defn.NothingType)
 
+  def assignType(tree: untpd.WhileDo)(implicit ctx: Context) =
+    tree.withType(defn.UnitType)
+
   def assignType(tree: untpd.Try, expr: Tree, cases: List[CaseDef])(implicit ctx: Context) =
     if (cases.isEmpty) tree.withType(expr.tpe)
     else tree.withType(ctx.typeComparer.lub(expr.tpe :: cases.tpes))
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 3865c5e39f76..6e5807bbd1f3 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1137,6 +1137,12 @@ class Typer extends Namer
     assignType(cpy.Return(tree)(expr1, from))
   }
 
+  def typedWhileDo(tree: untpd.WhileDo)(implicit ctx: Context): Tree = track("typedWhileDo") {
+    val cond1 = typed(tree.cond, defn.BooleanType)
+    val body1 = typed(tree.body, defn.UnitType)
+    assignType(cpy.WhileDo(tree)(cond1, body1))
+  }
+
   def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context): Try = track("typedTry") {
     val expr2 :: cases2x = harmonic(harmonize) {
       val expr1 = typed(tree.expr, pt.notApplied)
@@ -1889,6 +1895,7 @@ class Typer extends Namer
           case tree: untpd.Import => typedImport(tree, retrieveSym(tree))
           case tree: untpd.Match => typedMatch(tree, pt)
           case tree: untpd.Return => typedReturn(tree)
+          case tree: untpd.WhileDo => typedWhileDo(tree)
           case tree: untpd.Try => typedTry(tree, pt)
           case tree: untpd.Throw => typedThrow(tree)
           case tree: untpd.TypeApply => typedTypeApply(tree, pt)
diff --git a/library/src/scala/tasty/util/ShowExtractors.scala b/library/src/scala/tasty/util/ShowExtractors.scala
index 22da8dd63343..ccdbd4fc5b16 100644
--- a/library/src/scala/tasty/util/ShowExtractors.scala
+++ b/library/src/scala/tasty/util/ShowExtractors.scala
@@ -62,6 +62,8 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += "Term.Match(" += selector += ", " ++= cases += ")"
       case Term.Return(expr) =>
         this += "Term.Return(" += expr += ")"
+      case Term.While(cond, body) =>
+        this += "Term.While(" += cond += ", " += body += ")"
       case Term.Try(block, handlers, finalizer) =>
         this += "Term.Try(" += block += ", " ++= handlers += ", " += finalizer += ")"
       case Term.Repeated(elems) =>
diff --git a/library/src/scala/tasty/util/ShowSourceCode.scala b/library/src/scala/tasty/util/ShowSourceCode.scala
index 02e8e054109a..c8c423a41b40 100644
--- a/library/src/scala/tasty/util/ShowSourceCode.scala
+++ b/library/src/scala/tasty/util/ShowSourceCode.scala
@@ -227,16 +227,16 @@ 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)
 
-      case Term.DoWhile(body, cond) =>
-        this += "do "
-        printTree(body) += " while "
-        inParens(printTree(cond))
-
       case IsDefDef(ddef @ DefDef(name, targs, argss, tpt, rhs)) =>
         printDefAnnotations(ddef)
 
diff --git a/scala-backend b/scala-backend
index 0e7ec5de6024..47eaa7fbbc65 160000
--- a/scala-backend
+++ b/scala-backend
@@ -1 +1 @@
-Subproject commit 0e7ec5de60247d44aa4609bb8e194437a36596e8
+Subproject commit 47eaa7fbbc6549e4ad8a07c1d644e947eef9b9bd
diff --git a/tests/run-with-compiler/quote-inline-function.check b/tests/run-with-compiler/quote-inline-function.check
index 9399f7e158c7..bb2c20fd6091 100644
--- a/tests/run-with-compiler/quote-inline-function.check
+++ b/tests/run-with-compiler/quote-inline-function.check
@@ -7,11 +7,12 @@ Normal function
     f.apply(x$1)
     i = i.+(1)
   }
-  do {
+  while ({
     val x$2: scala.Int = i
     f.apply(x$2)
     i = i.+(1)
-  } while (i.<(j))
+    i.<(j)
+  }) ()
 }
 
 By name function
@@ -23,9 +24,10 @@ By name function
     scala.Predef.println(x$1)
     i = i.+(1)
   }
-  do {
+  while ({
     val x$2: scala.Int = i
     scala.Predef.println(x$2)
     i = i.+(1)
-  } while (i.<(j))
+    i.<(j)
+  }) ()
 }

From 2acfbf83d81601fc8ff6d3ea1aa1a57dc023ae8c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Tue, 18 Sep 2018 11:04:47 +0200
Subject: [PATCH 2/2] Remove `DoWhile` from tasty-reflect.

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.
---
 .../tools/dotc/tastyreflect/TreeOpsImpl.scala  |  8 --------
 library/src/scala/tasty/reflect/TreeOps.scala  |  6 ------
 .../src/scala/tasty/util/ShowSourceCode.scala  | 18 ++++++++++--------
 3 files changed, 10 insertions(+), 22 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
index b5f02eae7c15..4dbe00b76415 100644
--- 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
index f084120f6dd8..dec65a71f800 100644
--- 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
index c8c423a41b40..7f5fa3ed79f2 100644
--- 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)