Overloading with context function bug

[soronpo]

This bug is related to #14699, which was solved but we missed a case for context function blocks.

Compiler version

v3.1.3-RC2

Minimized code

See https://scastie.scala-lang.org/ftY9Wn6KQvC81LR30o3jUA

trait Ctx
given Ctx with {}
def always(block: Ctx ?=> Unit): Unit = {}
def always(args: Int*)(block: Ctx ?=> Unit): Unit ={}

always{} //error
always(1,2,3) {}

Output

None of the overloaded alternatives of method always in object Playground with types
 (args: Int*)(block: (Playground.Ctx) ?=> Unit): Unit
 (block: (Playground.Ctx) ?=> Unit): Unit
match arguments (Unit)

Expectation

No error.

[som-snytt]

Generally, an argument to an overloaded method is typechecked without an expected type (with an exception for inferring function types), so in that case, the argument is not wrapped in a context function.

Writing the explicit function literal works:

val _ = always { (x: Ctx) ?=> () }

Similar overloading that does not work:

def g(init: String ?=> Int)(s: String): Int = init(using s)
def g(init: Int ?=> Int)(j: Int): Int = init(using j)
g((i: Int) ?=> i+1)(41) == 42  // ok
g(summon[Int]+1)(41) == 42 // no

In this case, it's possible to pick an overload based on the second parameter list, but it's not possible to typecheck the first argument in advance; it could test applicability after overload resolution or try each context function type in turn.