extension method reports missing context value too eagerly

[scf37]

Compiler version

3.3.1

Minimized code

import scala.language.experimental.saferExceptions

def foo(): CanThrow[Exception] ?=> String = throw Exception("my error")

extension [A](v: CanThrow[Exception] ?=> A)
  inline def handle(inline f: Throwable => A): A = try v catch case e: Exception => f(e)

def test =
  println(foo().handle(_.getMessage))

Output

The capability to throw exception Exception is missing.
The capability can be provided by one of the following:
 - 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:

  import unsafeExceptions.canThrowAny

Expectation

Successful compilation. foo().handle(_.getMessage) is actually lazy evaluation of foo() within handle so exception gets caught.

[bishabosha]

minimised without can throw:

class CT[+T <: Exception]

def foo(): CT[Exception] ?=> String = throw Exception("my error")

extension [A](inline v: CT[Exception] ?=> A)
  transparent inline def handle(inline f: Throwable => A): A =
    try {given CT[Exception] = ???; v} catch case e: Exception => f(e)

def test =
  println(foo().handle(_.getMessage))

error:

-- [E172] Type Error: ----------------------------------------------------------
10 |  println(foo().handle(_.getMessage))
   |               ^
   |No given instance of type CT[Exception] was found for parameter of (CT[Exception]) ?=> String
1 error found

[bishabosha]

this variant without extension compiles fine:

class CT[+T <: Exception]

def foo(): CT[Exception] ?=> String = throw Exception("my error")\

transparent inline def handle[A](inline v: CT[Exception] ?=> A)(inline f: Throwable => A): A =
  try {given CT[Exception] = ???; v} catch case e: Exception => f(e)

def test =
  println(handle(foo())(_.getMessage))

[scf37]

Actually it is not inline-related:

class Context

def foo(): Context ?=> String = "hello"

extension [A](v: Context ?=> A)
  def handle(): A = 
    given Context()
    v

def test =
  println(foo().handle()) // No given instance of type Context was found for parameter of (Context) ?=> String

It seems implicit search does not understand foo().handle() is actually calling foo within handle

[nicolasstucki]

Minimization

extension (v: Int ?=> String) def handle: String = ???
def test = (??? : Int ?=> String).handle