Revert "Suppress returns that cross different stack sizes."

This reverts commit 04e7bc1.

Author: odersky

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

@@ -38,7 +38,7 @@ object DropBreaks:
  *    - the throw and the boundary are in the same method, and
  *    - there is no try expression inside the boundary that encloses the throw.
  */
-class DropBreaks extends MiniPhase, RecordStackChange:
+class DropBreaks extends MiniPhase:
   import DropBreaks.*
 
   import tpd._
@@ -158,12 +158,6 @@ class DropBreaks extends MiniPhase, RecordStackChange:
         ctx.fresh.setProperty(ShadowedLabels, setSoFar ++ usesMap.keysIterator)
       case _ => ctx
 
-  /** Need to suppress labeled returns if the stack can change between
-   *  source and target of the jump
-   */
-  protected def stackChange(using Context) =
-    ctx // if enclosingBoundaries == 0 then ctx else shadowLabels
-
   /** Need to suppress labeled returns if there is an intervening try
    */
   override def prepareForTry(tree: Try)(using Context): Context =
@@ -172,18 +166,13 @@ class DropBreaks extends MiniPhase, RecordStackChange:
       case LabelTry(_, _) => ctx
       case _ => shadowLabels
 
-  override def prepareForApply(tree: Apply)(using Context): Context =
-    if enclosingBoundaries == 0 then ctx
-    else tree match
-      case Break(_, _) => ctx
-      case _ => stackChange
-
   override def prepareForValDef(tree: ValDef)(using Context): Context =
-    if tree.symbol.is(Lazy) && tree.symbol.owner == ctx.owner.enclosingMethod then shadowLabels
+    if enclosingBoundaries != 0
+        && tree.symbol.is(Lazy)
+        && tree.symbol.owner == ctx.owner.enclosingMethod
+    then shadowLabels // RHS be converted to a lambda
     else ctx
 
-  // other stack changing operations are handled in RecordStackChange
-
   /** If `tree` is a BreakBoundary, transform it as follows:
    *   - Wrap it in a labeled block if its label has local uses
    *   - Drop the try/catch if its label has no other uses
@@ -203,7 +192,27 @@ class DropBreaks extends MiniPhase, RecordStackChange:
     case _ =>
       tree
 
-  /** Rewrite a break with argument `arg` and label `lbl`
+  private def isBreak(sym: Symbol)(using Context): Boolean =
+    sym.name == nme.apply && sym.owner == defn.breakModule.moduleClass
+
+  private def transformBreak(tree: Tree, arg: Tree, lbl: Symbol)(using Context): Tree =
+    report.log(i"transform break $tree/$arg/$lbl")
+    labelUsage(lbl) match
+      case Some(uses: LabelUsage)
+      if uses.enclMeth == ctx.owner.enclosingMethod
+          && !ctx.property(ShadowedLabels).getOrElse(Set.empty).contains(lbl)
+        =>
+        uses.otherRefs -= 1
+        uses.returnRefs += 1
+        Return(arg, ref(uses.goto)).withSpan(arg.span)
+      case _ =>
+        tree
+
+
+  /** Rewrite a break call
+   *
+   *     break.apply[...](value)(using lbl)
+   *
    *  where `lbl` is a label defined in the current method and is not included in
    *  ShadowedLabels to
    *

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

@@ -6,8 +6,8 @@ import core.DenotTransformers._
 import core.Symbols._
 import core.Contexts._
 import core.Types._
-import core.Decorators._
 import core.Flags._
+import core.Decorators._
 import core.NameKinds.LiftedTreeName
 import NonLocalReturns._
 import util.Store
@@ -27,7 +27,7 @@ import util.Store
  *  after an exception, so the fact that values on the stack are 'lost' does not matter
  *  (copied from https://github.com/scala/scala/pull/922).
  */
-class LiftTry extends MiniPhase, IdentityDenotTransformer, RecordStackChange { thisPhase =>
+class LiftTry extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   import ast.tpd._
 
   override def phaseName: String = LiftTry.name
@@ -40,14 +40,35 @@ class LiftTry extends MiniPhase, IdentityDenotTransformer, RecordStackChange { t
   override def initContext(ctx: FreshContext): Unit =
     NeedLift = ctx.addLocation(false)
 
-  private def liftingCtx(p: Boolean)(using Context): Context =
+  private def liftingCtx(p: Boolean)(using Context) =
     if (needLift == p) ctx else ctx.fresh.updateStore(NeedLift, p)
 
-  protected def stackChange(using Context): Context = liftingCtx(true)
+  override def prepareForApply(tree: Apply)(using Context): Context =
+    liftingCtx(true)
 
   override def prepareForDefDef(tree: DefDef)(using Context): Context =
     liftingCtx(false)
 
+  override def prepareForValDef(tree: ValDef)(using Context): Context =
+    if !tree.symbol.exists
+       || tree.symbol.isSelfSym
+       || tree.symbol.owner == ctx.owner.enclosingMethod
+          && !tree.symbol.is(Lazy)
+            // The current implementation wraps initializers of lazy vals in
+            // calls to an initialize method, which means that a `try` in the
+            // initializer needs to be lifted. Note that the new scheme proposed
+            // in #6979 would avoid this.
+    then ctx
+    else liftingCtx(true)
+
+  override def prepareForAssign(tree: Assign)(using Context): Context =
+    if (tree.lhs.symbol.maybeOwner == ctx.owner.enclosingMethod) ctx
+    else liftingCtx(true)
+
+  override def prepareForReturn(tree: Return)(using Context): Context =
+    if (!isNonLocalReturn(tree)) ctx
+    else liftingCtx(true)
+
   override def prepareForTemplate(tree: Template)(using Context): Context =
     liftingCtx(false)
 

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

@@ -5,7 +5,7 @@ object lib:
   extension [T](op: => T) inline def rescue (fallback: => T) =
     try op
     catch
-      case ex: boundary.Break => throw ex
+      case ex: boundary.Break[_] => throw ex
       case NonFatal(_) => fallback
 
   extension [T, E <: Throwable](op: => T) inline def rescue (fallback: PartialFunction[E, T]) =