Make tests variance aware

Author: odersky

tests/neg/safeThrowsStrawman.check

@@ -4,5 +4,13 @@
    |                                The capability to throw exception scalax.Fail is missing.
    |                                The capability can be provided by one of the following:
    |                                 - A using clause `(using CanThrow[scalax.Fail])`
-   |                                 - A throws clause in a result type `X throws scalax.Fail`
+   |                                 - A throws clause in a result type such as `X throws scalax.Fail`
    |                                 - an enclosing `try` that catches scalax.Fail
+-- Error: tests/neg/safeThrowsStrawman.scala:27:15 ---------------------------------------------------------------------
+27 |    println(bar)        // error
+   |               ^
+   |               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

tests/neg/safeThrowsStrawman.scala

@@ -2,10 +2,10 @@ import language.experimental.erasedTerms
 import annotation.implicitNotFound
 
 object scalax:
-  @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 `X throws ${E}`\n - an enclosing `try` that catches ${E}")
-  erased class CanThrow[E <: Exception]
+  @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}")
+  erased class CanThrow[-E <: Exception]
 
-  infix type throws[R, E <: Exception] = CanThrow[E] ?=> R
+  infix type throws[R, +E <: Exception] = CanThrow[E] ?=> R
 
   class Fail extends Exception
 
@@ -16,10 +16,14 @@ import scalax._
 def foo(x: Boolean): Int =
   if x then 1 else raise(Fail())  // error
 
+def bar: Int throws Exception =
+  raise(Fail())
+
 @main def Test =
   try
     erased given CanThrow[Fail] = ???
     println(foo(true))
     println(foo(false))
+    println(bar)        // error
   catch case ex: Fail =>
     println("failed")

tests/run/safeThrowsStrawman.scala

@@ -1,9 +1,9 @@
 import language.experimental.erasedTerms
 
 object scalax:
-  erased class CanThrow[E <: Exception]
+  erased class CanThrow[-E <: Exception]
 
-  infix type throws[R, E <: Exception] = CanThrow[E] ?=> R
+  infix type throws[R, +E <: Exception] = CanThrow[E] ?=> R
 
   class Fail extends Exception
 
@@ -14,8 +14,8 @@ import scalax._
 def foo(x: Boolean): Int throws Fail =
   if x then 1 else raise(Fail())
 
-def bar(x: Boolean)(using CanThrow[Fail]): Int =
-  if x then 1 else raise(Fail())
+def bar(x: Boolean)(using CanThrow[Fail]): Int = foo(x)
+def baz: Int throws Exception = foo(false)
 
 @main def Test =
   try
@@ -24,3 +24,8 @@ def bar(x: Boolean)(using CanThrow[Fail]): Int =
     println(foo(false))
   catch case ex: Fail =>
     println("failed")
+  try
+    given CanThrow[Exception] = ???
+    println(baz)
+  catch case ex: Fail =>
+    println("failed")