Eta-expand methods even if the expected type is a polymorphic function

In that case, let eta-expansion produce an untyped monomorphic lambda as usual.
Thanks to the previous commit, a type parameter clause for this lambda will be
inferred if possible.

Author: smarter

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -4344,6 +4344,29 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           if isApplyProxy(tree) then newExpr
           else if pt.isInstanceOf[PolyProto] then tree
           else
+            if Feature.enabled(Feature.typeClauseInference) then
+              // If `tree` is a polymorphic method reference and the expected
+              // type is a polymorphic function, perform a monomorphic
+              // eta-expansion of the method reference.
+              // For example, this means that
+              //
+              //     (1, 2.0).map(Option.apply)
+              //
+              // will expand to:
+              //
+              //     (1, 2.0).map(x => Option.apply(x))
+              //
+              // A type parameter clause for the lambda will subsequently be
+              // inferred (from its expected type) in typedFunctionValue.
+              pt match
+                case defn.PolyFunctionOf(_: PolyType) =>
+                  poly.resultType match
+                    case mt: MethodType =>
+                      val expanded = etaExpand(tree, mt, mt.paramInfos.length)
+                      return simplify(typed(expanded, pt), pt, locked)
+                    case _ =>
+                case _ =>
+            end if
             var typeArgs = tree match
               case Select(qual, nme.CONSTRUCTOR) => qual.tpe.widenDealias.argTypesLo.map(TypeTree(_))
               case _ => Nil

tests/neg/typeClauseInference.scala

@@ -1,3 +1,7 @@
 import scala.language.experimental.typeClauseInference
 
 val notInScopeInferred: [T] => T => T = x => (x: T) // error
+
+def bar[A]: A => A = x => x
+val barf1: [T] => T => T = bar(_) // ok
+val barf2: [T] => T => T = bar // error, unlike in the original SIP-49.

tests/pos/typeClauseInference.scala

@@ -7,5 +7,14 @@ class Test:
     val it3: [T, S <: List[T]] => (T, S) => List[T] = (x, y) => x :: y
     val tuple1: (String, String) = (1, 2.0).map[[_] =>> String](_.toString)
     val tuple2: (List[Int], List[Double]) = (1, 2.0).map(List(_))
-    // Not supported yet, require eta-expansion with a polymorphic expected type
-    // val tuple3: (List[Int], List[Double]) = (1, 2.0).map(List.apply)
+
+    // Eta-expansion
+    val e1: [T] => T => Option[T] = Option.apply
+    val tuple3: (Option[Int], Option[Double]) = (1, 2.0).map(Option.apply)
+
+    // Eta-expansion that wouldn't work with the original SIP-49
+    def pair[S, T](x: S, y: T): (S, T) = (x, y)
+    val f5: [T] => (Int, T) => (Int, T) = pair
+    val f6: [T] => (T, Int) => (T, Int) = pair
+    def id[T](x: T): T = x
+    val f7: [S] => List[S] => List[S] = id