Regression (since Scala 2) in handling of by-name parameters when typing arguments to polymorphic method

[mbore]

Compiler version

3.0.1;
3.1.0

Minimized code

def f(i: => Int): String = i.toString()

object Test {
  def test[RES](factory: () => RES): RES = ???
  def test[A, RES](factory: (A) => RES): RES = ???
}

Test.test(f _)

Output

[error] -- [E134] Type Error: [...]/TestMain.scala:23:5 
[error] 23 |Test.test(f _)
[error]    |^^^^^^^^^
[error]    |None of the overloaded alternatives of method test in object Test with types
[error]    | [A, RES](factory: A => RES): RES
[error]    | [RES](factory: () => RES): RES
[error]    |match arguments ((=> Int) => String)

Expectation

In Scala 2.13.6 it compiles, so I expect it to compile in 3.0.1 as well

[SethTisue]

I don't think overloading is essential here. If I comment out the first overload

% scala-cli repl -S 3.1.0
Welcome to Scala 3.1.0 (1.8.0_312, Java OpenJDK 64-Bit Server VM).
                                                                                                                        
scala> def f(i: => Int): String = i.toString()
     | 
     | object Test {
     | //  def test[RES](factory: () => RES): RES = ???
     |   def test[A, RES](factory: (A) => RES): RES = ???
     | }
     | 
     | Test.test(f _)
-- Error:
8 |Test.test(f _)
  |          ^
  |          Found:    (=> Int) => String
  |          Required: Any => String

[SethTisue]

I had to convince myself that it was correct that Scala 2 allows this. SLS 3.5.4 (https://scala-lang.org/files/archive/spec/2.13/03-types.html#compatibility) is relevant; it says that e.g. Int conforms to =>Int. In Mateusz's code, A is in contravariant position, so that's why this compiles in Scala 2: Function1[=> Int, String] is a subtype of Function1[Int, String].

[dwijnand]

Additionally looks like the method needs to be polymorphic, otherwise it works:

scala> def f(i: => Int): String = i.toString()
def f(i: => Int): String

scala> def test(factory: Int => String): String = ""
def test(factory: Int => String): String

scala> test(f _)
val res0: String = ""

scala> def test[RES](factory: Int => RES): RES = ???
def test[RES](factory: Int => RES): RES

scala> test(f _)
-- Error:
1 |test(f _)
  |     ^
  |     Found:    (=> Int) => String
  |     Required: Int => String