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

@@ -33,6 +33,7 @@ object Feature:
   val pureFunctions = experimental("pureFunctions")
   val captureChecking = experimental("captureChecking")
   val into = experimental("into")
+  val typeClauseInference = experimental("typeClauseInference")
 
   val globalOnlyImports: Set[TermName] = Set(pureFunctions, captureChecking)
 

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -1462,6 +1462,32 @@ 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 Feature.enabled(Feature.typeClauseInference) then
+      // 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 each S'_i is fresh and has the bounds of S_i after substituting S_j by S'_j for all j)
+      pt match
+        case defn.PolyFunctionOf(poly @ PolyType(_, mt: MethodType))
+        if 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

@@ -98,6 +98,9 @@ object language:
      */
     @compileTimeOnly("`into` can only be used at compile time in import statements")
     object into
+
+    @compileTimeOnly("`typeClauseInference` can only be used at compile time in import statements")
+    object typeClauseInference
   end experimental
 
   /** The deprecated object contains features that are no longer officially suypported in Scala.

library/src/scala/runtime/stdLibPatches/language.scala

@@ -0,0 +1,3 @@
+import scala.language.experimental.typeClauseInference
+
+val notInScopeInferred: [T] => T => T = x => (x: T) // error

tests/neg/typeClauseInference.scala

@@ -0,0 +1,11 @@
+import language.experimental.typeClauseInference
+
+class Test:
+  def test: Unit =
+    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)