automatic eta-expansion should work for SAM expected type and function with single empty parameter clauses

[unkarjedy]

(same as https://github.com/lampepfl/dotty/issues/11414)

reproduction steps

using Scala "3.0.0-M3"

Example

abstract class Sam00 { def foo(): Int }
abstract class Sam1 { def foo(s: String): Int }

def foo00(): Int = 1
def foo1(s: String): Int = 1

val a: Sam00     = foo00
val b: () => Int = foo00

val c: Sam1          = foo1
val d: String => Int = foo1

val e: Sam1          = foo1 _
val f: String => Int = foo1 _

Problem

I would expect automatic eta-expansion work the same way for SAM expected type and Function expected type for functions with empty parameters: whether allow it or disallow
This is also taking into account that it works unified for 1-arity (currently it compiles OK for functions with non-empty parameters, for SAM and Function expected type)

[liufengyun]

Here is the specification for automatic eta-expansion in Scala 3:

• If m has an argument list with one or more parameters, we always eta-expand
• If m is has an empty argument list (i.e. has type ()R):
  1. If the expected type is of the form () => T, we eta expand.
  2. If m is defined by Java, or overrides a Java defined method, we insert ().
  3. Otherwise we issue an error of the form:

Thus, an unapplied method with an empty argument list is only converted to a function when a function type is expected. It is considered best practice to either explicitly apply the method to (), or convert it to a function with () => m().

The nullary methods are explicitly treated differently, due to possible interaction with auto-application.