Introduce boundary/break control abstraction. (#16612)

The abstractions are intended to replace the `scala.util.control.Breaks`
and
`scala.util.control.NonLocalReturns`. They are simpler, safer, and more
performant,
since there is a new MiniPhase `DropBreaks` that rewrites local breaks
to labeled
returns, i.e. jumps.

The abstractions are not experimental. This break from usual procedure
is because
we need to roll them out fast. Non local returns were just deprecated in
3.2, and
we proposed `NonLocalReturns.{returning,throwReturn}` as an alternative.
But these
APIs were a mistake and should be deprecated themselves. So rolling out
boundary/break now counts
as a bugfix.

Author: odersky

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

@@ -970,6 +970,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) = {