Refactoring of break methiod calls

Move the detected `break` methods into the `boundary` object and keep inline
methods in object `scala.util.break` as facades.

Author: odersky

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

@@ -968,9 +968,9 @@ 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 breakModule: Symbol = requiredModule("scala.util.break")
 
   @tu lazy val CapsModule: Symbol = requiredModule("scala.caps")
     @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("*")

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

@@ -421,6 +421,7 @@ object StdNames {
     val assert_ : N             = "assert"
     val assume_ : N             = "assume"
     val box: N                  = "box"
+    val break: N                = "break"
     val build : N               = "build"
     val bundle: N               = "bundle"
     val bytes: N                = "bytes"

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

@@ -105,7 +105,7 @@ class DropBreaks extends MiniPhase:
   private object Break:
 
     private def isBreak(sym: Symbol)(using Context): Boolean =
-      sym.name == nme.apply && sym.owner == defn.breakModule.moduleClass
+      sym.name == nme.break && sym.owner == defn.boundaryModule.moduleClass
 
     /** `(local, arg)` provided `tree` matches
      *
@@ -193,7 +193,7 @@ class DropBreaks extends MiniPhase:
       tree
 
   private def isBreak(sym: Symbol)(using Context): Boolean =
-    sym.name == nme.apply && sym.owner == defn.breakModule.moduleClass
+    sym.name == nme.break && sym.owner == defn.boundaryModule.moduleClass
 
   private def transformBreak(tree: Tree, arg: Tree, lbl: Symbol)(using Context): Tree =
     report.log(i"transform break $tree/$arg/$lbl")

library/src/scala/util/boundary.scala

@@ -24,8 +24,19 @@ object boundary:
 
   /** Labels are targets indicating which boundary will be exited by a `break`.
    */
-  final class Label[-T]:
-    private[util] def break(value: T): Nothing = throw Break(this, value)
+  final class Label[-T]
+
+  /** Abort current computation and instead return `value` as the value of
+   *  the enclosing `boundary` call that created `label`.
+   */
+  def break[T](value: T)(using label: Label[T]): Nothing =
+    throw Break(label, value)
+
+  /** Abort current computation and instead continue after the `boundary` call that
+   *  created `label`.
+   */
+  def break()(using label: Label[Unit]): Nothing =
+    throw Break(label, ())
 
   /** Run `body` with freshly generated label as implicit argument. Catch any
    *  breaks associated with that label and return their results instead of

library/src/scala/util/break.scala

@@ -6,15 +6,19 @@ package scala.util
 object break:
 
   /** Abort current computation and instead return `value` as the value of
-   *  the enclosing `boundary` call that created `label`.
+   *  the enclosing `boundary` call that created `label`. Expands to
+   *
+   *      boundary.break(value)(using label)
    */
-  def apply[T](value: T)(using label: boundary.Label[T]): Nothing =
-    label.break(value)
+  inline def apply[T](value: T)(using label: boundary.Label[T]): Nothing =
+    boundary.break(value)
 
   /** Abort current computation and instead continue after the `boundary` call that
-   *  created `label`.
+   *  created `label`. Expands to
+   *
+   *      boundary.break()(using label)
    */
-  def apply()(using label: boundary.Label[Unit]): Nothing =
-    label.break(())
+  inline def apply()(using label: boundary.Label[Unit]): Nothing =
+    boundary.break()
 
 end break