Automatic rewrite for <function> _ can produce non-compiling code for curried functions

[WojciechMazur]

Issue found when applying automatic rewrites for sagifogel/proptics in Open CB

Compiler version

All Scala 3.4+ versions

Minimized code

//> using options -Ykind-projector
import scala.collection.SortedMap

trait NonEmptyMap[K, +A]:
  def toSortedMap: SortedMap[K, A]
  
trait FoldableWithIndex[F[_], I]:
  def test[K] = new FoldableWithIndex[NonEmptyMap[K, *], K] {
    def foldLeftWithIndex[A, B](f: (B, (A, K)) => B)(fa: NonEmptyMap[K, A], b: B): B =
      mapLikeFoldLeftWithIndex((fa.toSortedMap.foldLeft[B] _))(f)(b)
  }

  def mapLikeFoldLeftWithIndex[A, B, K](foldLeft: B => ((B, (K, A)) => B) => B)(f: (B, (A, K)) => B)(b: B): B = ???

Output

//> using options -Ykind-projector
import scala.collection.SortedMap

trait NonEmptyMap[K, +A]:
  def toSortedMap: SortedMap[K, A]
  
trait FoldableWithIndex[F[_], I]:
  def test[K] = new FoldableWithIndex[NonEmptyMap[K, *], K] {
    def foldLeftWithIndex[A, B](f: (B, (A, K)) => B)(fa: NonEmptyMap[K, A], b: B): B =
      mapLikeFoldLeftWithIndex(((() => fa.toSortedMap.foldLeft[B])))(f)(b)
  }

  def mapLikeFoldLeftWithIndex[A, B, K](foldLeft: B => ((B, (K, A)) => B) => B)(f: (B, (A, K)) => B)(b: B): B = ???

-- [E007] Type Mismatch Error: /Users/wmazur/projects/sandbox/src/main/scala/schema.scala:10:39 
10 |      mapLikeFoldLeftWithIndex(((() => fa.toSortedMap.foldLeft[B])))(f)(b)
   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |                             Found:    B => Any
   |                             Required: ((Any, (Any, Any)) => Any) => Any
   |
   | longer explanation available when compiling with `-explain`

Expectation

The compiler should not suggest an automatic rewrite when the function is curried. Other cases for rewrite should be also considered

[bracevac]

De-noised example:

//> using options -rewrite -source 3.4-migration 
trait Indirect:
  def fun(x: Int)(y: Int): Int

trait Container:
  def indirectDef: Indirect
  val indirectVal: Indirect
  def fun(x: Int)(y: Int): Int
  
def test(c: Container): Int =
    use(c.indirectDef.fun _) // becomes (() => c.indirectDef.fun), WRONG! Should be c.indirectDef.fun
  + use(c.indirectVal.fun _) // becomes c.indirectVal.fun, OK!
  + use(c.fun _)             // becomes c.fun, OK!

def use(f: Int => Int => Int): Int = ???

It appears the rewrite logic of #18926
does not correctly handle eta-expanding a method accessed through at least one other intermediate method.