Introduce boundary/break control abstraction.

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

@@ -4,7 +4,7 @@ package jvm
 
 import scala.language.unsafeNulls
 
-import scala.annotation.switch
+import scala.annotation.{switch, tailrec}
 import scala.collection.mutable.SortedMap
 
 import scala.tools.asm
@@ -79,9 +79,14 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
 
       tree match {
         case Assign(lhs @ DesugaredSelect(qual, _), rhs) =>
+          val savedStackHeight = stackHeight
           val isStatic = lhs.symbol.isStaticMember
-          if (!isStatic) { genLoadQualifier(lhs) }
+          if (!isStatic) {
+            genLoadQualifier(lhs)
+            stackHeight += 1
+          }
           genLoad(rhs, symInfoTK(lhs.symbol))
+          stackHeight = savedStackHeight
           lineNumber(tree)
           // receiverClass is used in the bytecode to access the field. using sym.owner may lead to IllegalAccessError
           val receiverClass = qual.tpe.typeSymbol
@@ -145,7 +150,9 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
           }
 
           genLoad(larg, resKind)
+          stackHeight += resKind.size
           genLoad(rarg, if (isShift) INT else resKind)
+          stackHeight -= resKind.size
 
           (code: @switch) match {
             case ADD => bc add resKind
@@ -182,14 +189,19 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       if (isArrayGet(code)) {
         // load argument on stack
         assert(args.length == 1, s"Too many arguments for array get operation: $tree");
+        stackHeight += 1
         genLoad(args.head, INT)
+        stackHeight -= 1
         generatedType = k.asArrayBType.componentType
         bc.aload(elementType)
       }
       else if (isArraySet(code)) {
         val List(a1, a2) = args
+        stackHeight += 1
         genLoad(a1, INT)
+        stackHeight += 1
         genLoad(a2)
+        stackHeight -= 2
         generatedType = UNIT
         bc.astore(elementType)
       } else {
@@ -223,7 +235,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
           val resKind       = if (hasUnitBranch) UNIT else tpeTK(tree)
 
           val postIf = new asm.Label
-          genLoadTo(thenp, resKind, LoadDestination.Jump(postIf))
+          genLoadTo(thenp, resKind, LoadDestination.Jump(postIf, stackHeight))
           markProgramPoint(failure)
           genLoadTo(elsep, resKind, LoadDestination.FallThrough)
           markProgramPoint(postIf)
@@ -482,7 +494,17 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       dest match
         case LoadDestination.FallThrough =>
           ()
-        case LoadDestination.Jump(label) =>
+        case LoadDestination.Jump(label, targetStackHeight) =>
+          if targetStackHeight < stackHeight then
+            val stackDiff = stackHeight - targetStackHeight
+            if expectedType == UNIT then
+              bc dropMany stackDiff
+            else
+              val loc = locals.makeTempLocal(expectedType)
+              bc.store(loc.idx, expectedType)
+              bc dropMany stackDiff
+              bc.load(loc.idx, expectedType)
+          end if
           bc goTo label
         case LoadDestination.Return =>
           bc emitRETURN returnType
@@ -577,7 +599,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       if dest == LoadDestination.FallThrough then
         val resKind = tpeTK(tree)
         val jumpTarget = new asm.Label
-        registerJumpDest(labelSym, resKind, LoadDestination.Jump(jumpTarget))
+        registerJumpDest(labelSym, resKind, LoadDestination.Jump(jumpTarget, stackHeight))
         genLoad(expr, resKind)
         markProgramPoint(jumpTarget)
         resKind
@@ -635,7 +657,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       markProgramPoint(loop)
 
       if isInfinite then
-        val dest = LoadDestination.Jump(loop)
+        val dest = LoadDestination.Jump(loop, stackHeight)
         genLoadTo(body, UNIT, dest)
         dest
       else
@@ -650,7 +672,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
             val failure = new asm.Label
             genCond(cond, success, failure, targetIfNoJump = success)
             markProgramPoint(success)
-            genLoadTo(body, UNIT, LoadDestination.Jump(loop))
+            genLoadTo(body, UNIT, LoadDestination.Jump(loop, stackHeight))
             markProgramPoint(failure)
         end match
         LoadDestination.FallThrough
@@ -744,7 +766,9 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
 
           // scala/bug#10290: qual can be `this.$outer()` (not just `this`), so we call genLoad (not just ALOAD_0)
           genLoad(superQual)
+          stackHeight += 1
           genLoadArguments(args, paramTKs(app))
+          stackHeight -= 1
           generatedType = genCallMethod(fun.symbol, InvokeStyle.Super, app.span)
 
         // 'new' constructor call: Note: since constructors are
@@ -766,7 +790,9 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
               assert(classBTypeFromSymbol(ctor.owner) == rt, s"Symbol ${ctor.owner.showFullName} is different from $rt")
               mnode.visitTypeInsn(asm.Opcodes.NEW, rt.internalName)
               bc dup generatedType
+              stackHeight += 2
               genLoadArguments(args, paramTKs(app))
+              stackHeight -= 2
               genCallMethod(ctor, InvokeStyle.Special, app.span)
 
             case _ =>
@@ -799,8 +825,12 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
               else if (app.hasAttachment(BCodeHelpers.UseInvokeSpecial)) InvokeStyle.Special
               else InvokeStyle.Virtual
 
-            if (invokeStyle.hasInstance) genLoadQualifier(fun)
+            val savedStackHeight = stackHeight
+            if invokeStyle.hasInstance then
+              genLoadQualifier(fun)
+              stackHeight += 1
             genLoadArguments(args, paramTKs(app))
+            stackHeight = savedStackHeight
 
             val DesugaredSelect(qual, name) = fun: @unchecked // fun is a Select, also checked in genLoadQualifier
             val isArrayClone = name == nme.clone_ && qual.tpe.widen.isInstanceOf[JavaArrayType]
@@ -858,6 +888,8 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       bc iconst   elems.length
       bc newarray elmKind
 
+      stackHeight += 3 // during the genLoad below, there is the result, its dup, and the index
+
       var i = 0
       var rest = elems
       while (!rest.isEmpty) {
@@ -869,6 +901,8 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         i = i + 1
       }
 
+      stackHeight -= 3
+
       generatedType
     }
 
@@ -883,7 +917,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       val (generatedType, postMatch, postMatchDest) =
         if dest == LoadDestination.FallThrough then
           val postMatch = new asm.Label
-          (tpeTK(tree), postMatch, LoadDestination.Jump(postMatch))
+          (tpeTK(tree), postMatch, LoadDestination.Jump(postMatch, stackHeight))
         else
           (expectedType, null, dest)
 
@@ -1160,14 +1194,21 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
     }
 
     def genLoadArguments(args: List[Tree], btpes: List[BType]): Unit =
-      args match
-        case arg :: args1 =>
-          btpes match
-            case btpe :: btpes1 =>
-              genLoad(arg, btpe)
-              genLoadArguments(args1, btpes1)
-            case _ =>
-        case _ =>
+      @tailrec def loop(args: List[Tree], btpes: List[BType]): Unit =
+        args match
+          case arg :: args1 =>
+            btpes match
+              case btpe :: btpes1 =>
+                genLoad(arg, btpe)
+                stackHeight += btpe.size
+                loop(args1, btpes1)
+              case _ =>
+          case _ =>
+
+      val savedStackHeight = stackHeight
+      loop(args, btpes)
+      stackHeight = savedStackHeight
+    end genLoadArguments
 
     def genLoadModule(tree: Tree): BType = {
       val module = (
@@ -1266,11 +1307,14 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
             }.sum
             bc.genNewStringBuilder(approxBuilderSize)
 
+            stackHeight += 1 // during the genLoad below, there is a reference to the StringBuilder on the stack
             for (elem <- concatArguments) {
               val elemType = tpeTK(elem)
               genLoad(elem, elemType)
               bc.genStringBuilderAppend(elemType)
             }
+            stackHeight -= 1
+
             bc.genStringBuilderEnd
           } else {
 
@@ -1287,12 +1331,15 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
             var totalArgSlots = 0
             var countConcats = 1     // ie. 1 + how many times we spilled
 
+            val savedStackHeight = stackHeight
+
             for (elem <- concatArguments) {
               val tpe = tpeTK(elem)
               val elemSlots = tpe.size
 
               // Unlikely spill case
               if (totalArgSlots + elemSlots >= MaxIndySlots) {
+                stackHeight = savedStackHeight + countConcats
                 bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result())
                 countConcats += 1
                 totalArgSlots = 0
@@ -1317,8 +1364,10 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
                   val tpe = tpeTK(elem)
                   argTypes += tpe.toASMType
                   genLoad(elem, tpe)
+                  stackHeight += 1
               }
             }
+            stackHeight = savedStackHeight
             bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result())
 
             // If we spilled, generate one final concat
@@ -1513,7 +1562,9 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         } else {
           val tk = tpeTK(l).maxType(tpeTK(r))
           genLoad(l, tk)
+          stackHeight += tk.size
           genLoad(r, tk)
+          stackHeight -= tk.size
           genCJUMP(success, failure, op, tk, targetIfNoJump)
         }
       }
@@ -1628,7 +1679,9 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         }
 
         genLoad(l, ObjectRef)
+        stackHeight += 1
         genLoad(r, ObjectRef)
+        stackHeight -= 1
         genCallMethod(equalsMethod, InvokeStyle.Static)
         genCZJUMP(success, failure, Primitives.NE, BOOL, targetIfNoJump)
       }
@@ -1644,7 +1697,9 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         } else if (isNonNullExpr(l)) {
           // SI-7852 Avoid null check if L is statically non-null.
           genLoad(l, ObjectRef)
+          stackHeight += 1
           genLoad(r, ObjectRef)
+          stackHeight -= 1
           genCallMethod(defn.Any_equals, InvokeStyle.Virtual)
           genCZJUMP(success, failure, Primitives.NE, BOOL, targetIfNoJump)
         } else {
@@ -1654,7 +1709,9 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
           val lNonNull = new asm.Label
 
           genLoad(l, ObjectRef)
+          stackHeight += 1
           genLoad(r, ObjectRef)
+          stackHeight -= 1
           locals.store(eqEqTempLocal)
           bc dup ObjectRef
           genCZJUMP(lNull, lNonNull, Primitives.EQ, ObjectRef, targetIfNoJump = lNull)

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

@@ -620,6 +620,16 @@ trait BCodeIdiomatic {
     // can-multi-thread
     final def drop(tk: BType): Unit = { emit(if (tk.isWideType) Opcodes.POP2 else Opcodes.POP) }
 
+    // can-multi-thread
+    final def dropMany(size: Int): Unit = {
+      var s = size
+      while s >= 2 do
+        emit(Opcodes.POP2)
+        s -= 2
+      if s > 0 then
+        emit(Opcodes.POP)
+    }
+
     // can-multi-thread
     final def dup(tk: BType): Unit =  { emit(if (tk.isWideType) Opcodes.DUP2 else Opcodes.DUP) }
 

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

@@ -45,7 +45,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     /** The value is put on the stack, and control flows through to the next opcode. */
     case FallThrough
     /** The value is put on the stack, and control flow is transferred to the given `label`. */
-    case Jump(label: asm.Label)
+    case Jump(label: asm.Label, targetStackHeight: Int)
     /** The value is RETURN'ed from the enclosing method. */
     case Return
     /** The value is ATHROW'n. */
@@ -368,6 +368,8 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     // used by genLoadTry() and genSynchronized()
     var earlyReturnVar: Symbol     = null
     var shouldEmitCleanup          = false
+    // stack tracking
+    var stackHeight                = 0
     // line numbers
     var lastEmittedLineNr          = -1
 
@@ -504,6 +506,13 @@ trait BCodeSkelBuilder extends BCodeHelpers {
         loc
       }
 
+      def makeTempLocal(tk: BType): Local =
+        assert(nxtIdx != -1, "not a valid start index")
+        assert(tk.size > 0, "makeLocal called for a symbol whose type is Unit.")
+        val loc = Local(tk, "temp", nxtIdx, isSynth = true)
+        nxtIdx += tk.size
+        loc
+
       // not to be confused with `fieldStore` and `fieldLoad` which also take a symbol but a field-symbol.
       def store(locSym: Symbol): Unit = {
         val Local(tk, _, idx, _) = slots(locSym)
@@ -574,6 +583,8 @@ trait BCodeSkelBuilder extends BCodeHelpers {
       earlyReturnVar      = null
       shouldEmitCleanup   = false
 
+      stackHeight = 0
+
       lastEmittedLineNr = -1
     }
 

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -88,7 +88,8 @@ class Compiler {
          new sjs.ExplicitJSClasses,  // Make all JS classes explicit (Scala.js only)
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
-         new StringInterpolatorOpt) :: // Optimizes raw and s and f string interpolators by rewriting them to string concatenations or formats
+         new StringInterpolatorOpt,  // Optimizes raw and s and f string interpolators by rewriting them to string concatenations or formats
+         new DropBreaks) ::          // Optimize local Break throws by rewriting them 
     List(new PruneErasedDefs,        // Drop erased definitions from scopes and simplify erased expressions
          new UninitializedDefs,      // Replaces `compiletime.uninitialized` by `_`
          new InlinePatterns,         // Remove placeholders of inlined patterns

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -102,6 +102,12 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
     case _ => tree
   }
 
+  def stripTyped(tree: Tree): Tree = unsplice(tree) match
+    case Typed(expr, _) =>
+      stripTyped(expr)
+    case _ =>
+      tree
+
   /** The number of arguments in an application */
   def numArgs(tree: Tree): Int = unsplice(tree) match {
     case Apply(fn, args) => numArgs(fn) + args.length

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -968,6 +968,10 @@ class Definitions {
   def TupledFunctionClass(using Context): ClassSymbol = TupledFunctionTypeRef.symbol.asClass
   def RuntimeTupleFunctionsModule(using Context): Symbol = requiredModule("scala.runtime.TupledFunctions")
 
+  @tu lazy val boundaryModule: Symbol = requiredModule("scala.util.boundary")
+  @tu lazy val LabelClass: Symbol = requiredClass("scala.util.boundary.Label")
+  @tu lazy val BreakClass: Symbol = requiredClass("scala.util.boundary.Break")
+
   @tu lazy val CapsModule: Symbol = requiredModule("scala.caps")
     @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("*")
     @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")

compiler/src/dotty/tools/dotc/core/NameKinds.scala

@@ -325,6 +325,8 @@ object NameKinds {
 
   val LocalOptInlineLocalObj: UniqueNameKind = new UniqueNameKind("ilo")
 
+  val BoundaryName: UniqueNameKind           = new UniqueNameKind("boundary")
+
   /** The kind of names of default argument getters */
   val DefaultGetterName: NumberedNameKind = new NumberedNameKind(DEFAULTGETTER, "DefaultGetter") {
     def mkString(underlying: TermName, info: ThisInfo) = {