Patch DropBreaks to correctly detect boundary blocks

We previously had the `ex.label eq label` comparision, which is no longer the case,
with the (package) private label field.

Author: natsukagami

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

@@ -530,6 +530,7 @@ object StdNames {
     val isEmpty: N              = "isEmpty"
     val isInstanceOf_ : N       = "isInstanceOf"
     val isInstanceOfPM: N       = "$isInstanceOf$"
+    val isSameLabelAs : N       = "isSameLabelAs"
     val java: N                 = "java"
     val key: N                  = "key"
     val label: N                = "label"

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

@@ -63,10 +63,10 @@ class DropBreaks extends MiniPhase:
        */
       def unapply(expr: Tree)(using Context): Option[(Symbol, Symbol)] = stripTyped(expr) match
         case If(
-          Apply(Select(Select(ex: Ident, label), eq), (lbl @ Ident(local)) :: Nil),
+          Apply(Select(ex: Ident, isSameLabelAs), (lbl @ Ident(local)) :: Nil),
           Select(ex2: Ident, value),
           Apply(throww, (ex3: Ident) :: Nil))
-        if label == nme.label && eq == nme.eq && local == nme.local && value == nme.value
+        if isSameLabelAs == nme.isSameLabelAs && local == nme.local && value == nme.value
             && throww.symbol == defn.throwMethod
             && ex.symbol == ex2.symbol && ex.symbol == ex3.symbol =>
           Some((ex.symbol, lbl.symbol))

library/src/scala/util/boundary.scala

@@ -1,4 +1,6 @@
 package scala.util
+
+import language.experimental.captureChecking
 import scala.annotation.implicitNotFound
 
 /** A boundary that can be exited by `break` calls.
@@ -31,9 +33,17 @@ object boundary:
   /** User code should call `break.apply` instead of throwing this exception
    *  directly.
    */
-  final class Break[T] private[boundary](val label: Label[T], val value: T)
+  final class Break[T] private[boundary](private[boundary] val label: Label[T]^{}, val value: T)
   extends RuntimeException(
-    /*message*/ null, /*cause*/ null, /*enableSuppression=*/ false, /*writableStackTrace*/ false)
+    /*message*/ null, /*cause*/ null, /*enableSuppression=*/ false, /*writableStackTrace*/ false):
+    /** Compare the given [[Label]] to the one this [[Break]] was constructed with. */
+    def isSameLabelAs(other: Label[T]) = label eq other
+
+  object Break:
+    import caps.unsafe.unsafeAssumePure
+    def apply[T](label: Label[T], value: T) =
+      // SAFETY: labels cannot leak from [[Break]], and is only used for equality comparison.
+      new Break(label.unsafeAssumePure, value)
 
   /** Labels are targets indicating which boundary will be exited by a `break`.
    */