Add syntactic sugar for polymorphic function types

Desugar the type
    [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 }

Author: smarter

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

@@ -1090,6 +1090,15 @@ 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
+        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)
+        ))
       case SymbolLit(str) =>
         Literal(Constant(scala.Symbol(str)))
       case Quote(expr) =>

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

@@ -59,6 +59,12 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   /** A function type with `implicit` or `erased` modifiers */
   class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers) extends Function(args, body)
 
+  /** A polymorphic function type */
+  case class PolyFunction(targs: List[Tree], body: Tree) extends Tree {
+    override def isTerm = body.isTerm
+    override def isType = body.isType
+  }
+
   /** A function created from a wildcard expression
    *  @param  placeholderParams  a list of definitions of synthetic parameters.
    *  @param  body               the function body where wildcards are replaced by
@@ -436,6 +442,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: Function if (args eq tree.args) && (body eq tree.body) => tree
       case _ => finalize(tree, untpd.Function(args, body))
     }
+    def PolyFunction(tree: Tree)(targs: List[Tree], body: Tree) = tree match {
+      case tree: PolyFunction if (targs eq tree.targs) && (body eq tree.body) => tree
+      case _ => finalize(tree, untpd.PolyFunction(targs, body))
+    }
     def InfixOp(tree: Tree)(left: Tree, op: Ident, right: Tree) = tree match {
       case tree: InfixOp if (left eq tree.left) && (op eq tree.op) && (right eq tree.right) => tree
       case _ => finalize(tree, untpd.InfixOp(left, op, right))

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

@@ -792,6 +792,8 @@ object Parsers {
           val tparams = typeParamClause(ParamOwner.TypeParam)
           if (in.token == ARROW)
             atPos(start, in.skipToken())(LambdaTypeTree(tparams, toplevelTyp()))
+          else if (isIdent && in.name.toString == "->")
+            atPos(start, in.skipToken())(PolyFunction(tparams, toplevelTyp()))
           else { accept(ARROW); typ() }
         }
         else infixType()

tests/run/polymorphic-functions.scala

@@ -1,5 +1,5 @@
 object Test {
-  def test1(f: PolyFunction { def apply[T <: AnyVal](x: List[T]): List[(T, T)] }) = {
+  def test1(f: [T <: AnyVal] -> List[T] => List[(T, T)]) = {
     f(List(1, 2, 3))
   }