Backport new ControlThrowable

Backport `scala.util.control.ControlThrowable` from
2.13 (which does not suppress exceptions or have a
stack trace) as `scala.util.control.compat.ControlThrowable`
(it still extends previous Scala versions'
`scala.util.control.ControlThrowable`).

Author: NthPortal

compat/src/main/scala-2.11_2.12/scala/util/control/compat/ControlThrowable.scala

@@ -0,0 +1,54 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+package scala.util.control.compat
+
+/** A parent class for throwable objects intended for flow control.
+ *
+ *  Instances of `ControlThrowable` should not normally be caught.
+ *
+ *  As a convenience, `NonFatal` does not match `ControlThrowable`.
+ *
+ *  {{{
+ *  import scala.util.control.{Breaks, NonFatal}, Breaks.{break, breakable}
+ *
+ *  breakable {
+ *    for (v <- values) {
+ *      try {
+ *        if (p(v)) break
+ *        else ???
+ *      } catch {
+ *        case NonFatal(t) => log(t)  // can't catch a break
+ *      }
+ *    }
+ *  }
+ *  }}}
+ *
+ *  Suppression is disabled, because flow control should not suppress
+ *  an exceptional condition. Stack traces are also disabled, allowing
+ *  instances of `ControlThrowable` to be safely reused.
+ *
+ *  Instances of `ControlThrowable` should not normally have a cause.
+ *  Legacy subclasses may set a cause using `initCause`.
+ *
+ *  @note this compat class exists so that instances of `ControlThrowable`
+ *        can be created using the same API and with the same suppression
+ *        and stack trace writability semantics across versions.
+ */
+abstract class ControlThrowable(message: String)
+    extends Throwable(message, /*cause=*/ null, /*enableSuppression=*/ false,
+                      /*writableStackTrace=*/ false)
+    with scala.util.control.ControlThrowable {
+
+  override def fillInStackTrace(): Throwable = super[Throwable].fillInStackTrace()
+
+  def this() = this(message = null)
+}

compat/src/main/scala-2.13/scala/util/control/compat/package.scala

@@ -0,0 +1,5 @@
+package scala.util.control
+
+package object compat {
+  type ControlThrowable = scala.util.control.ControlThrowable
+}

compat/src/test/scala/scala/util/control/compat/ControlThrowableTest.scala

@@ -0,0 +1,17 @@
+package scala.util.control.compat
+
+import org.junit.Test
+
+class ControlThrowableTest {
+  @Test
+  def doesNotSuppress(): Unit = {
+    val t = new ControlThrowable {}
+    t.addSuppressed(new Exception)
+    assert(t.getSuppressed.isEmpty)
+  }
+
+  @Test
+  def doesNotHaveStackTrace(): Unit = {
+    assert(new ControlThrowable {}.getStackTrace.isEmpty)
+  }
+}