Strange type mismatch error when function type is expected + eta-expansion

[unkarjedy]

Scala 3.7.3 with -explain compiler flag

Use the code example below:

class A

//
// Strange errors
//
def bar(): String = null
bar: (() => String) //OK
bar _: (() => String) //OK (with warning for deprecated `_`)

// Strange error: Found: () => Unit Required: A => Unit
val a: A => Unit = (bar _)
// Strange error: Found: String Required: Int
val b: A => Int = (bar _)

//
// Good errors
//
// Good error: Found: () => String Required: A => String
val c: A => String = (bar _)

val f: () => String = null
// Good error: Found: () => String Expected A => Unit 
val x: A => Unit = f
// Good error: Found: () => String Expected A => Int 
val y: A => Int = f
// Good error: Found: () => String Expected A => String 
val z: A => String = f

Note that for values c, x, y,z the type mismatch error text is quite expected.
However for a and b the errors look strange and misleading.

Foe example, for val a: A => Unit = (bar _) the error is as such:

Found: () => Unit
Required: A => Unit

Explanation
===========

Tree:

() =>
{
bar()
()
}

I tried to show that
() => Unit
conforms to
A => Unit
but none of the attempts shown below succeeded:

==> () => Unit <: A => Unit = false

The tests were made under the empty constraint

Why the explicitly-eta-expanded (bar _) was tried to be called and wrapped in () => { bar() } (leading to the strange () => Unit "Found" type)?

And for val b: A => Int = (bar _) it's

Found: String
Required: Int

Explanation
===========

Tree:

bar1()

I tried to show that
String
conforms to
Int
but none of the attempts shown below succeeded:

==> String <: Int = false

The tests were made under the empty constraint

Again, not clear, quite confusing.
Why the tree is not () => bar1() here?
Why it only checks the return type here ignoring the param types?

Similar situation with e.g.

def bar2(x: A): String = null
val a2: () => Unit = bar2 _
val b2: () => Int = bar2 _

[unkarjedy]

A related question, why in this code, the "Type mismatch" error is even generated?

class A

def bar(): String = null
val a1: A => Unit = bar
val b1: A => Int = bar
val c1: A => String = bar

According to the new Automatic eta-expansion and nullary methods rules

Automatic eta expansion does not apply to "nullary" methods that take an empty parameter list.
Given a simple reference to next does not auto-convert to a function. One has to write explicitly () => next() to achieve that

So I would expect only error with text "Method bar must be called with () argument" and not the type mismatch error.
Or, if generating the type mismatch error, it should be Found: String, Expected A => Unit/Int/String

[som-snytt]

The details are https://docs.scala-lang.org/scala3/reference/changed-features/eta-expansion-spec.html

where

If the expected type is of the form () => T, we eta expand.

I think adapting the result of the function () => Unit is either a feature or gotcha. (It features on a recent ticket, perhaps I can find it.)

The next example is unfortunate. Is it "grandfathered in" because lib is Scala 2?

Welcome to Scala 3.7.3 (25, Java OpenJDK 64-Bit Server VM).
Type in expressions for evaluation. Or try :help.

scala> def huh() = 17
def huh(): Int

scala> val f: () => Int = huh
val f: () => Int = Lambda/0x000000006647d420@79273a4f

scala> val g = huh
-- [E100] Syntax Error: --------------------------------------------------------
1 |val g = huh
  |        ^^^
  |        method huh must be called with () argument
  |
  | longer explanation available when compiling with `-explain`
1 error found

scala> val it = List(42).iterator
val it: Iterator[Int] = <iterator>

scala> val g = it.next
val g: Int = 42

Here, it's just adapting the result to expected type Unit:

scala> def f = 42
[[syntax trees at end of                     typer]] // rs$line$1
package <empty> {
  final lazy module val rs$line$1: rs$line$1 = new rs$line$1()
  final module class rs$line$1() extends Object() { this: rs$line$1.type =>
    def f: Int = 42
  }
}

def f: Int

scala> val g: () => Unit = f
-- [E007] Type Mismatch Error: -------------------------------------------------
1 |val g: () => Unit = f
  |                    ^
  |                    Found:    Int
  |                    Required: () => Unit
  |
  | longer explanation available when compiling with `-explain`
[[syntax trees at end of                     typer]] // rs$line$2
package <empty> {
  final lazy module val rs$line$2: rs$line$2 = new rs$line$2()
  final module class rs$line$2() extends Object() { this: rs$line$2.type =>
    val g: () => Unit = f
  }
}

1 error found

scala> val g: () => Unit = () => f
[[syntax trees at end of                     typer]] // rs$line$2
package <empty> {
  final lazy module val rs$line$2: rs$line$2 = new rs$line$2()
  final module class rs$line$2() extends Object() { this: rs$line$2.type =>
    val g: () => Unit = () =>
      {
        f
        ()
      }
  }
}

val g: () => Unit = Lambda/0x000000001a4e4420@75aeec0a

So that is not mysterious. It is weird because misleading?

scala> val g: Int => Int = () => f
-- [E007] Type Mismatch Error: -------------------------------------------------
1 |val g: Int => Int = () => f
  |                    ^^^^^^^
  |                    Found:    () => Int
  |                    Required: Int => Int
  |
  | longer explanation available when compiling with `-explain`
[[syntax trees at end of                     typer]] // rs$line$3
package <empty> {
  final lazy module val rs$line$3: rs$line$3 = new rs$line$3()
  final module class rs$line$3() extends Object() { this: rs$line$3.type =>
    val g: Int => Int = () => f
  }
}

1 error found

scala> val g: Int => String = () => f
-- [E007] Type Mismatch Error: -------------------------------------------------
1 |val g: Int => String = () => f
  |                             ^
  |                             Found:    Int
  |                             Required: String
  |
  | longer explanation available when compiling with `-explain`
[[syntax trees at end of                     typer]] // rs$line$3
package <empty> {
  final lazy module val rs$line$3: rs$line$3 = new rs$line$3()
  final module class rs$line$3() extends Object() { this: rs$line$3.type =>
    val g: Int => String = () => f
  }
}

1 error found

scala> val g: Int => String = () => f.toString
-- [E007] Type Mismatch Error: -------------------------------------------------
1 |val g: Int => String = () => f.toString
  |                       ^^^^^^^^^^^^^^^^
  |                       Found:    () => String
  |                       Required: Int => String
  |
  | longer explanation available when compiling with `-explain`
[[syntax trees at end of                     typer]] // rs$line$3
package <empty> {
  final lazy module val rs$line$3: rs$line$3 = new rs$line$3()
  final module class rs$line$3() extends Object() { this: rs$line$3.type =>
    val g: Int => String = () => f.toString()
  }
}

1 error found

[unkarjedy]

The next example is unfortunate. Is it "grandfathered in" because lib is Scala 2?

Yes:
https://docs.scala-lang.org/scala3/reference/dropped-features/auto-apply.html

For reasons of backwards compatibility, Scala 3 for the moment also auto-inserts () for nullary methods that are defined in Scala 2, or that override a method defined in Scala 2. It turns out that, because the correspondence between definition and call was not enforced in Scala so far, there are quite a few method definitions in Scala 2 libraries that use () in an inconsistent way. For instance, we find in scala.math.Numeric

• "method apply must be called with () argument" must be generated for scala.Function0 #21351 (comment)

[Gedochao]

Note: I suppose the requirement for addressing this would be to improve the error messages.