wip

Author: sjrd

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -61,6 +61,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   type If              = tpd.If
   type ValDef          = tpd.ValDef
   type Throw           = tpd.Apply
+  type Labeled         = tpd.Labeled
   type Return          = tpd.Return
   type Block           = tpd.Block
   type Typed           = tpd.Typed
@@ -193,6 +194,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   implicit val LabelDefTag: ClassTag[LabelDef] = ClassTag[LabelDef](classOf[LabelDef])
   implicit val ValDefTag: ClassTag[ValDef] = ClassTag[ValDef](classOf[ValDef])
   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 LiteralTag: ClassTag[Literal] = ClassTag[Literal](classOf[Literal])
   implicit val BlockTag: ClassTag[Block] = ClassTag[Block](classOf[Block])
@@ -1076,8 +1078,14 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def apply(s: Symbol): This = tpd.This(s.asClass)
   }
 
+  object Labeled extends LabeledDeconstructor {
+    def _1: Bind = field.bind
+    def _2: Tree = field.expr
+  }
+
   object Return extends ReturnDeconstructor {
-    def get = field.expr
+    def _1: Tree = field.expr
+    def _2: Symbol = if (field.from.symbol.isLabel) field.from.symbol else NoSymbol
   }
 
   object Ident extends IdentDeconstructor {

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -352,8 +352,14 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         else changePrec(GlobalPrec) { toText(sel) ~ keywordStr(" match ") ~ blockText(cases) }
       case CaseDef(pat, guard, body) =>
         keywordStr("case ") ~ inPattern(toText(pat)) ~ optText(guard)(keywordStr(" if ") ~ _) ~ " => " ~ caseBlockText(body)
+      case Labeled(bind, expr) =>
+        changePrec(GlobalPrec) { toText(bind.name) ~ keywordStr("[") ~ toText(bind.symbol.info) ~ keywordStr("]: ") ~ toText(expr) }
       case Return(expr, from) =>
-        changePrec(GlobalPrec) { keywordStr("return") ~ optText(expr)(" " ~ _) }
+        val sym = from.symbol
+        if (sym.is(Label))
+          changePrec(GlobalPrec) { keywordStr("return@") ~ toText(sym.name) ~ optText(expr)(" " ~ _) }
+        else
+          changePrec(GlobalPrec) { keywordStr("return") ~ optText(expr)(" " ~ _) }
       case Try(expr, cases, finalizer) =>
         changePrec(GlobalPrec) {
           keywordStr("try ") ~ toText(expr) ~ optText(cases)(keywordStr(" catch ") ~ _) ~ optText(finalizer)(keywordStr(" finally ") ~ _)

compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala

@@ -11,7 +11,7 @@ import collection.mutable
 object NonLocalReturns {
   import ast.tpd._
   def isNonLocalReturn(ret: Return)(implicit ctx: Context) =
-    ret.from.symbol != ctx.owner.enclosingMethod || ctx.owner.is(Lazy)
+    !ret.from.symbol.is(Label) && (ret.from.symbol != ctx.owner.enclosingMethod || ctx.owner.is(Lazy))
 }
 
 /** Implement non-local returns using NonLocalReturnControl exceptions.

scala-backend

@@ -1,3 +1,15 @@
 object HelloWorld {
-  def main(args: Array[String]): Unit = println("hello world")
+  def main(args: Array[String]): Unit = {
+    println("hello world")
+    val list = List(1, 2, 3)
+    list match {
+      case head :: tail => println(head)
+      case Nil => println("empty")
+    }
+    val s = list match {
+      case head :: tail => head.toString
+      case Nil => "empty"
+    }
+    println(s)
+  }
 }