Better handling of multiple exceptions for saferExceptions - reworks

Author: prolativ

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1753,18 +1753,16 @@ class Typer extends Namer
       if Feature.enabled(Feature.saferExceptions) then
         for
           CaseDef(pat, guard, _) <- cases
-          tpe = pat.tpe.widen
-          if tpe.isCheckedException
+          if pat.tpe.widen.isCheckedException
         yield
           checkCatch(pat, guard)
-          tpe
+          pat.tpe.widen
       else Seq.empty
 
-    caughtExceptions match
-      case Nil => expr
-      case head :: tail =>
-        val capabilityProof = tail.foldLeft(head: Type)(OrType(_, _, true))
-        untpd.Block(makeCanThrow(capabilityProof), expr)
+    if caughtExceptions.isEmpty then expr
+    else
+      val capabilityProof = caughtExceptions.reduce(OrType(_, _, true))
+      untpd.Block(makeCanThrow(capabilityProof), expr)
 
   def typedTry(tree: untpd.Try, pt: Type)(using Context): Try = {
     val expr2 :: cases2x = harmonic(harmonize, pt) {

docs/docs/reference/experimental/canthrow.md

@@ -162,9 +162,9 @@ You'll get this error message:
                                ^^^^^^^^^^^^^^^^^^^^^
 The capability to throw exception LimitExceeded is missing.
 The capability can be provided by one of the following:
- - A using clause `(using CanThrow[LimitExceeded])`
- - A `throws` clause in a result type such as `X throws LimitExceeded`
- - an enclosing `try` that catches LimitExceeded
+ - Adding a using clause `(using CanThrow[LimitExceeded])` to the definition of the enclosing method
+ - Adding `throws LimitExceeded` clause after the result type of the enclosing method
+ - Wrapping this piece of code with a `try` block that catches LimitExceeded
 
 The following import might fix the problem:
 

library/src/scala/CanThrow.scala

@@ -7,7 +7,7 @@ import annotation.{implicitNotFound, experimental}
  *  a given of class `CanThrow[Ex]` to be available.
  */
 @experimental
-@implicitNotFound("The capability to throw exception ${E} is missing.\nThe capability can be provided by one of the following:\n - A using clause `(using CanThrow[${E}])`\n - A `throws` clause in a result type such as `X throws ${E}`\n - an enclosing `try` that catches ${E}")
+@implicitNotFound("The capability to throw exception ${E} is missing.\nThe capability can be provided by one of the following:\n - Adding a using clause `(using CanThrow[${E}])` to the definition of the enclosing method\n - Adding `throws ${E}` clause after the result type of the enclosing method\n - Wrapping this piece of code with a `try` block that catches ${E}")
 erased class CanThrow[-E <: Exception]
 
 @experimental

tests/neg/i13846.check

@@ -5,13 +5,13 @@
 -- Error: tests/neg/i13846.scala:7:9 -----------------------------------------------------------------------------------
 7 |    foo() // error
   |         ^
-  |         The capability to throw exception ArithmeticException is missing.
-  |         The capability can be provided by one of the following:
-  |          - A using clause `(using CanThrow[ArithmeticException])`
-  |          - A `throws` clause in a result type such as `X throws ArithmeticException`
-  |          - an enclosing `try` that catches ArithmeticException
+  |        The capability to throw exception ArithmeticException is missing.
+  |        The capability can be provided by one of the following:
+  |         - Adding a using clause `(using CanThrow[ArithmeticException])` to the definition of the enclosing method
+  |         - Adding `throws ArithmeticException` clause after the result type of the enclosing method
+  |         - Wrapping this piece of code with a `try` block that catches ArithmeticException
   |
-  |         The following import might fix the problem:
+  |        The following import might fix the problem:
   |
-  |           import unsafeExceptions.canThrowAny
+  |          import unsafeExceptions.canThrowAny
   |

tests/neg/i13864.check

@@ -8,9 +8,9 @@
   |          ^
   |          The capability to throw exception Ex[Int] is missing.
   |          The capability can be provided by one of the following:
-  |           - A using clause `(using CanThrow[Ex[Int]])`
-  |           - A `throws` clause in a result type such as `X throws Ex[Int]`
-  |           - an enclosing `try` that catches Ex[Int]
+  |           - Adding a using clause `(using CanThrow[Ex[Int]])` to the definition of the enclosing method
+  |           - Adding `throws Ex[Int]` clause after the result type of the enclosing method
+  |           - Wrapping this piece of code with a `try` block that catches Ex[Int]
   |
   |          The following import might fix the problem:
   |

tests/neg/saferExceptions.check

@@ -3,9 +3,9 @@
    |                ^^^^^^^^^^^^^^^^^
    |                The capability to throw exception Exception is missing.
    |                The capability can be provided by one of the following:
-   |                 - A using clause `(using CanThrow[Exception])`
-   |                 - A `throws` clause in a result type such as `X throws Exception`
-   |                 - an enclosing `try` that catches Exception
+   |                 - Adding a using clause `(using CanThrow[Exception])` to the definition of the enclosing method
+   |                 - Adding `throws Exception` clause after the result type of the enclosing method
+   |                 - Wrapping this piece of code with a `try` block that catches Exception
    |
    |                The following import might fix the problem:
    |
@@ -14,13 +14,13 @@
 -- Error: tests/neg/saferExceptions.scala:17:46 ------------------------------------------------------------------------
 17 |  def baz(x: Int): Int throws Failure = bar(x)  // error
    |                                              ^
-   |                                    The capability to throw exception java.io.IOException is missing.
-   |                                    The capability can be provided by one of the following:
-   |                                     - A using clause `(using CanThrow[java.io.IOException])`
-   |                                     - A `throws` clause in a result type such as `X throws java.io.IOException`
-   |                                     - an enclosing `try` that catches java.io.IOException
+   |      The capability to throw exception java.io.IOException is missing.
+   |      The capability can be provided by one of the following:
+   |       - Adding a using clause `(using CanThrow[java.io.IOException])` to the definition of the enclosing method
+   |       - Adding `throws java.io.IOException` clause after the result type of the enclosing method
+   |       - Wrapping this piece of code with a `try` block that catches java.io.IOException
    |
-   |                                    The following import might fix the problem:
+   |      The following import might fix the problem:
    |
-   |                                      import unsafeExceptions.canThrowAny
+   |        import unsafeExceptions.canThrowAny
    |

tests/pos/i13816.scala

@@ -4,28 +4,28 @@ class Ex1 extends Exception("Ex1")
 class Ex2 extends Exception("Ex2")
 
 def foo1(i: Int): Unit throws Ex1 throws Ex2 =
-   if i > 0 then throw new Ex1 else throw new Ex2
+  if i > 0 then throw new Ex1 else throw new Ex2
 
 def foo2(i: Int): Unit throws Ex1 | Ex2 =
-   if i > 0 then throw new Ex1 else throw new Ex2
+  if i > 0 then throw new Ex1 else throw new Ex2
 
 def foo3(i: Int): Unit throws (Ex1 | Ex2) =
-   if i > 0 then throw new Ex1 else throw new Ex2
+  if i > 0 then throw new Ex1 else throw new Ex2
 
 def foo4(i: Int)(using CanThrow[Ex1], CanThrow[Ex2]): Unit =
-   if i > 0 then throw new Ex1 else throw new Ex2
+  if i > 0 then throw new Ex1 else throw new Ex2
 
 def foo5(i: Int)(using CanThrow[Ex1])(using CanThrow[Ex2]): Unit =
-   if i > 0 then throw new Ex1 else throw new Ex2
+  if i > 0 then throw new Ex1 else throw new Ex2
 
 def foo6(i: Int)(using CanThrow[Ex1 | Ex2]): Unit =
-   if i > 0 then throw new Ex1 else throw new Ex2
+  if i > 0 then throw new Ex1 else throw new Ex2
 
 def foo7(i: Int)(using CanThrow[Ex1]): Unit throws Ex2 =
-   if i > 0 then throw new Ex1 else throw new Ex2
+  if i > 0 then throw new Ex1 else throw new Ex2
 
 def foo8(i: Int)(using CanThrow[Ex2]): Unit throws Ex1 =
-   if i > 0 then throw new Ex1 else throw new Ex2
+  if i > 0 then throw new Ex1 else throw new Ex2
 
 def test(): Unit =
   try
@@ -40,3 +40,18 @@ def test(): Unit =
   catch
     case _: Ex1 =>
     case _: Ex2 =>
+
+  try
+    try
+      foo1(1)
+      foo2(1)
+      foo3(1)
+      foo4(1)
+      foo5(1)
+      // foo6(1) // As explained in the docs this won't work until we find a way to aggregate capabilities
+      foo7(1)
+      foo8(1)
+    catch
+      case _: Ex1 =>
+  catch
+    case _: Ex2 =>