Overloading regression in Scala 3

[soronpo]

The following works in 2.13, but fails in Scala 3.

Compiler version

v3.1.2-RC1

Minimized code

https://scastie.scala-lang.org/eiWBjoMFRiWNNuBRV2oH2g

def always(block: => Unit): Unit = {}
def always(args: Int*)(block: => 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: => Unit): Unit
 (block: => Unit): Unit
match arguments (<nonsensical><notype></nonsensical>)

Expectation

No error, same as in Scala 2.13

[som-snytt]

I guess it works in 2.13 not because of specificity but because "if the result expr of the block is omitted, unit is assumed".

scala 2.13.8> object X {
            | def always(block: => Unit): Unit = println(s"OK $block")
            | def always(args: Int*)(block: => Unit): Unit = println(s"Well, ${args.sum} and $block")
            | }
object X

scala 2.13.8> X.always _
                ^
              error: ambiguous reference to overloaded definition,
              both method always in object X of type (args: Int*)(block: => Unit): Unit
              and  method always in object X of type (block: => Unit): Unit
              match expected type ?

scala 2.13.8> X.always {}
OK ()

I thought 2.13 preferred non-varargs, but by tupling and discarding

scala 2.13.8> def f(body: => Unit) = ()
def f(body: => Unit): Unit

scala 2.13.8> f(1,2,3)

Tangentially, #14700

[odersky]

I think this is indeed ambiguous according to spec.

[som-snytt]

The expectation is that if it works with explicit unit value, it should work when the unit value is implicit. Only one alternative is applicable.

scala> object X {
     | def always(block: => Unit): Unit = println(s"OK $block")
     | def always(args: Int*)(block: => Unit): Unit = println(s"Well, ${args.sum} and $block")
     | }
// defined object X

scala> X.always {()}
OK ()

scala> X.always {}
-- [E134] Type Error: --------------------------------------------------------------------------------------------------
1 |X.always {}
  |^^^^^^^^
  |None of the overloaded alternatives of method always in object X with types
  | (args: Int*)(block: => Unit): Unit
  | (block: => Unit): Unit
  |match arguments (<notype>)
1 error found

[soronpo]

I think this is indeed ambiguous according to spec.

Maybe the behavior is undefined according to the spec, but it's not defined that it's illegal as well. So where the spec is ambiguous/undefined we turn to the existing implementation. The Scala 2 compiler implementation accepts this as legal code. Therefore, I think we need to stick to that as the de facto specified behavior and treat the Scala 3 implementation as a regression.

[som-snytt]

@soronpo That comment meant that unapplied X.always is "ambiguous reference", as in the error message in my transcript, not that the spec is ambiguous on this point. But I think the error message you're getting is just a bug. My first comment wasn't clear.

I think my previous comment is the correct interpretation of X.always {}, namely, that it is the same as X.always {()} and should also work without controversy.

[odersky]

I misread the example. In fact there is no ambiguity. {} as an argument is equivalent to (()) and that determines the alternative unambiguously.

[soronpo]

Thank you @odersky