Add syntactic sugar for polymorphic function values

Desugar the value
    [T_1, ..., T_M] -> (x_1: P_1, ..., x_N: P_N) => body
Into
    new scala.PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N) = body }

Author: smarter

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1430,22 +1430,35 @@ object desugar {
     }
 
     val desugared = tree match {
-      case PolyFunction(targs, body) if (ctx.mode.is(Mode.Type)) =>
-        // Desugar [T_1, ..., T_M] -> (P_1, ..., P_N) => R
-        // Into    scala.PolyFunction { def apply[T_1, ..., T_M](x$1: P_1, ..., x$N: P_N): R }
-        val Function(vargs, resType) = body
+      case PolyFunction(targs, body) =>
+        val Function(vargs, res) = body
         // TODO: Figure out if we need a `PolyFunctionWithMods` instead.
         val mods = body match {
           case body: FunctionWithMods => body.mods
           case _ => untpd.EmptyModifiers
         }
+        val polyFunctionTpt = ref(defn.PolyFunctionType)
         val applyTParams = targs.asInstanceOf[List[TypeDef]]
-        val applyVParams = vargs.zipWithIndex.map { case (p, n) =>
-          makeSyntheticParameter(n + 1, p).withAddedFlags(mods.flags)
+        if (ctx.mode.is(Mode.Type)) {
+          // Desugar [T_1, ..., T_M] -> (P_1, ..., P_N) => R
+          // Into    scala.PolyFunction { def apply[T_1, ..., T_M](x$1: P_1, ..., x$N: P_N): R }
+
+          val applyVParams = vargs.zipWithIndex.map { case (p, n) =>
+            makeSyntheticParameter(n + 1, p).withAddedFlags(mods.flags)
+          }
+          RefinedTypeTree(polyFunctionTpt, List(
+            DefDef(nme.apply, applyTParams, List(applyVParams), res, EmptyTree)
+          ))
+        } else {
+          // Desugar [T_1, ..., T_M] -> (x_1: P_1, ..., x_N: P_N) => body
+          // Into    new scala.PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N) = body }
+
+          val applyVParams = vargs.asInstanceOf[List[ValDef]]
+            .map(varg => varg.withAddedFlags(mods.flags | Param))
+          New(Template(emptyConstructor, List(polyFunctionTpt), Nil, EmptyValDef,
+            List(DefDef(nme.apply, applyTParams, List(applyVParams), TypeTree(), res))
+          ))
         }
-        RefinedTypeTree(ref(defn.PolyFunctionType), List(
-          DefDef(nme.apply, applyTParams, List(applyVParams), resType, EmptyTree)
-        ))
       case SymbolLit(str) =>
         Literal(Constant(scala.Symbol(str)))
       case InterpolatedString(id, segments) =>

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1325,6 +1325,11 @@ object Parsers {
         atSpan(in.skipToken()) { Return(if (isExprIntro) expr() else EmptyTree, EmptyTree) }
       case FOR =>
         forExpr()
+      case LBRACKET =>
+        val start = in.offset
+        val tparams = typeParamClause(ParamOwner.TypeParam)
+        assert(isIdent && in.name.toString == "->", "Expected `->`")
+        atSpan(start, in.skipToken())(PolyFunction(tparams, expr()))
       case _ =>
         if (isIdent(nme.inline) && !in.inModifierPosition() && in.lookaheadIn(canStartExpressionTokens)) {
           val start = in.skipToken()

tests/run/polymorphic-functions.scala

@@ -4,9 +4,7 @@ object Test {
   }
 
   def main(args: Array[String]): Unit = {
-    val fun = new PolyFunction {
-      def apply[T <: AnyVal](x: List[T]): List[(T, T)] = x.map(e => (e, e))
-    }
+    val fun = [T <: AnyVal] -> (x: List[T]) => x.map(e => (e, e))
 
     assert(test1(fun) == List((1, 1), (2, 2), (3, 3)))
   }