Type parameter clause inference for lambdas

When a lambda is written without a type parameter clause but the expected type
is a polymorphic function type, try to adapt the lambda into a polymorphic
lambda by inferring an appropriate type parameter clause.

This change broke one example in spire which relied on implicit conversions.
The fix has been accepted upstream: typelevel/spire#1247

Author: smarter

community-build/community-projects/spire

@@ -1460,6 +1460,33 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   def typedFunctionValue(tree: untpd.Function, pt: Type)(using Context): Tree = {
     val untpd.Function(params: List[untpd.ValDef] @unchecked, _) = tree: @unchecked
 
+    // If the expected type is a polymorphic function type:
+    //
+    //    [S_1, ..., S_m] => (T_1, ..., T_n) => R
+    //    (where each S_i might have type bounds)
+    //
+    // and we are typing a lambda of the form:
+    //
+    //    (x_1, ..., x_n) => e
+    //    (where each x_i might have a type ascription)
+    //
+    // then continue with an inferred type parameter clause:
+    //
+    //    [S'_1, ..., S'_m] => (x_1, ..., x_n) => e
+    //    (where the bounds of S'_i are the bounds of S_i after substituting S_j by S'_j for all j)
+    pt match
+      case RefinedType(parent, nme.apply, poly @ PolyType(_, mt: MethodType))
+      if (parent.typeSymbol eq defn.PolyFunctionClass) &&
+         params.lengthCompare(mt.paramNames) == 0
+      =>
+        val tparams = poly.paramNames.lazyZip(poly.paramInfos).map: (name, info) =>
+          untpd.TypeDef(UniqueName.fresh(name), untpd.InLambdaTypeTree(isResult = false, (tsyms, vsyms) =>
+            info.substParams(poly, tsyms.map(_.typeRef))
+          )).withFlags(SyntheticParam)
+            .withSpan(tree.span.startPos)
+        return typed(untpd.PolyFunction(tparams, tree), pt)
+      case _ =>
+
     val (isContextual, isDefinedErased) = tree match {
       case tree: untpd.FunctionWithMods => (tree.mods.is(Given), tree.erasedParams)
       case _ => (false, tree.args.map(_ => false))

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

@@ -1,6 +1,13 @@
 -- [E035] Syntax Error: tests/neg/i13769.scala:2:21 --------------------------------------------------------------------
-2 |val te = tup.map((x: _ <: Int) => List(x)) // error
+2 |val te = tup.map((x: _ <: Int) => List(x)) // error // error
   |                     ^^^^^^^^
   |                     Unbound wildcard type
   |
   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i13769.scala:2:39 -------------------------------------------------------------
+2 |val te = tup.map((x: _ <: Int) => List(x)) // error // error
+  |                                       ^
+  |                                       Found:    (x : Any)
+  |                                       Required: t$1
+  |
+  | longer explanation available when compiling with `-explain`

tests/neg/i13769.check

@@ -1,2 +1,2 @@
 val tup = (1, "s")
-val te = tup.map((x: _ <: Int) => List(x)) // error
+val te = tup.map((x: _ <: Int) => List(x)) // error // error

tests/neg/i13769.scala

@@ -4,3 +4,5 @@ val wrongLength2: [T] => T => T = [T] => (x, x) => x // error
 val notSubType: [T] => T => T = [T <: Int] => x => x // error
 
 val notInScope: [T] => T => T = [S] => x => (x: T) // error
+
+val notInScopeInferred: [T] => T => T = x => (x: T) // error

tests/neg/polymorphic-functions2.scala

@@ -118,4 +118,13 @@ object Test extends App {
     [S, T <: List[S]] => (x, y) => x :: y
   val i4: [T, S <: List[T]] => (T, S) => List[T] =
     [T, S <: List[T]] => (x, y: S) => x :: y
+
+  // Inferred type clause
+  val it1: [T] => T => T = x => x
+  val it2: [T] => (T, Int) => T = (x, y: Int) => x
+  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)
 }