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

@@ -1090,15 +1090,28 @@ 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
+        val polyFunctionTpt = ref(defn.PolyFunctionType)
         val applyTParams = targs.asInstanceOf[List[TypeDef]]
-        val applyVParams = vargs.zipWithIndex.map({case (p, n) => makeSyntheticParameter(n + 1, p)})
-        RefinedTypeTree(ref(defn.PolyFunctionType), List(
-          DefDef(nme.apply, applyTParams, List(applyVParams), resType, EmptyTree)
-        ))
+        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)})
+          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.withMods(varg.mods | SyntheticTermParam))
+          New(Template(emptyConstructor, List(polyFunctionTpt), EmptyValDef,
+            List(DefDef(nme.apply, applyTParams, List(applyVParams), TypeTree(), res))
+          ))
+        }
       case SymbolLit(str) =>
         Literal(Constant(scala.Symbol(str)))
       case Quote(expr) =>

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

@@ -1194,6 +1194,11 @@ object Parsers {
         atPos(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 `->`")
+        atPos(start, in.skipToken())(PolyFunction(tparams, expr()))
       case _ =>
         expr1Rest(postfixExpr(), location)
     }

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)))
   }