Revise polymorphic function syntax

* Use => as the arrow rather than ->
* Term-parameterless polymorphic functions are now reported as
  unsupported due to an implementation restriction
* Added run/neg tests

Author: milessabin

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

@@ -924,9 +924,18 @@ object Parsers {
           val tparams = typeParamClause(ParamOwner.TypeParam)
           if (in.token == TLARROW)
             atSpan(start, in.skipToken())(LambdaTypeTree(tparams, toplevelTyp()))
-          else if (isIdent && in.name.toString == "->")
-            atSpan(start, in.skipToken())(PolyFunction(tparams, toplevelTyp()))
-          else { accept(TLARROW); typ() }
+          else if (in.token == ARROW) {
+            val arrowOffset = in.skipToken()
+            val body = toplevelTyp()
+            atSpan(start, arrowOffset) {
+              body match {
+                case _: Function => PolyFunction(tparams, body)
+                case _ =>
+                  syntaxError("Implementation restriction: polymorphic function types must have a value parameter", arrowOffset)
+                  Ident(nme.ERROR.toTypeName)
+              }
+            }
+          } else { accept(TLARROW); typ() }
         }
         else infixType()
 
@@ -1328,8 +1337,16 @@ object Parsers {
       case LBRACKET =>
         val start = in.offset
         val tparams = typeParamClause(ParamOwner.TypeParam)
-        assert(isIdent && in.name.toString == "->", "Expected `->`")
-        atSpan(start, in.skipToken())(PolyFunction(tparams, expr()))
+        val arrowOffset = accept(ARROW)
+        val body = expr()
+        atSpan(start, arrowOffset) {
+          body match {
+            case _: Function => PolyFunction(tparams, body)
+            case _ =>
+              syntaxError("Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
+              errorTermTree
+          }
+        }
       case _ =>
         if (isIdent(nme.inline) && !in.inModifierPosition() && in.lookaheadIn(canStartExpressionTokens)) {
           val start = in.skipToken()

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -561,7 +561,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case PolyFunction(targs, body) =>
         val targsText = "[" ~ Text(targs.map((arg: Tree) => toText(arg)), ", ") ~ "]"
         changePrec(GlobalPrec) {
-          targsText ~ " -> " ~ toText(body)
+          targsText ~ " => " ~ toText(body)
         }
       case InfixOp(l, op, r) =>
         val opPrec = parsing.precedence(op.name)

tests/neg/polymorphic-functions.scala

@@ -0,0 +1,5 @@
+object Test {
+  val pv0: [T] => List[T] = ???        // error
+  val pv1: Any = [T] => Nil            // error
+  val pv2: [T] => List[T] = [T] => Nil // error // error
+}

tests/run/polymorphic-functions.scala

@@ -1,11 +1,14 @@
-object Test {
-  def test1(f: [T <: AnyVal] -> List[T] => List[(T, T)]) = {
-    f(List(1, 2, 3))
-  }
+object Test extends App {
+  // Types
+  type F0 = [T] => List[T] => Option[T]
+  type F1 = [F[_], G[_], T] => (F[T], F[T] => G[T]) => G[T]
 
-  def main(args: Array[String]): Unit = {
-    val fun = [T <: AnyVal] -> (x: List[T]) => x.map(e => (e, e))
+  // Terms
+  val t0 = [T] => (ts: List[T]) => ts.headOption
+  val t0a: F0 = t0
+  assert(t0(List(1, 2, 3)) == Some(1))
 
-    assert(test1(fun) == List((1, 1), (2, 2), (3, 3)))
-  }
+  val t1 = [F[_], G[_], T] => (ft: F[T], f: F[T] => G[T]) => f(ft)
+  val t1a: F1 = t1
+  assert(t1(List(1, 2, 3), (ts: List[Int]) => ts.headOption) == Some(1))
 }