Merge pull request #73 from non/topic/typelambda-cleanup-v0

Topic/typelambda cleanup v0

Author: puffnfresh

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -928,7 +928,7 @@ self =>
 
       /** {{{
        *  SimpleType       ::=  SimpleType TypeArgs
-       *                     |  `[' Types `]' `=>' Type
+       *                     |  `[' VariantTypeParam {`,' VariantTypeParam} `]'] `=>' Type
        *                     |  SimpleType `#' Id
        *                     |  StableId
        *                     |  Path `.' type
@@ -944,7 +944,10 @@ self =>
           case LBRACKET =>
             atPos(start) {
               val ts = typeParamClauseOpt(freshTypeName("typelambda"), null)
-              if (in.token == ARROW) {
+              if (ts.isEmpty) {
+                syntaxError("missing type parameters", skipIt = false)
+                errorTypeTree
+              } else if (in.token == ARROW) {
                 in.skipToken()
                 makeTypeLambdaTypeTree(ts, typ())
               } else {

src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala

@@ -155,13 +155,13 @@ abstract class TreeBuilder {
 
   /** Create a type lambda tree */
   def makeTypeLambdaTypeTree(argtpes: List[TypeDef], restpe: Tree): Tree = {
-    val name = freshTypeName("L")
+    val name = freshTypeName("L$")
     SelectFromTypeTree(
       CompoundTypeTree(
         Template(
-          Select(Select(Ident("_root_"), "scala"), newTypeName("AnyRef")) :: Nil,
-          ValDef(Modifiers(0), "_", TypeTree(), EmptyTree),
-          TypeDef(Modifiers(0), name, argtpes, restpe) :: Nil)), name)
+          gen.rootScalaDot(tpnme.AnyRef) :: Nil,
+          ValDef(NoMods, nme.WILDCARD, TypeTree(), EmptyTree),
+          TypeDef(NoMods, name, argtpes, restpe) :: Nil)), name)
   }
 
   /** Append implicit parameter section if `contextBounds` nonempty */

test/files/neg/typelambda1.check

@@ -0,0 +1,4 @@
+typelambda1.scala:5: error: type L$1 takes type parameters
+  qux[[x] => [y] => (x, y)]
+             ^
+one error found

test/files/neg/typelambda1.scala

@@ -0,0 +1,6 @@
+object Test {
+
+  def qux[Q[_]] = 999
+
+  qux[[x] => [y] => (x, y)]
+}

test/files/neg/typelambda2.check

@@ -0,0 +1,18 @@
+typelambda2.scala:5: error: kinds of the type arguments ([x[_]] => x[Double]) do not conform to the expected kinds of the type parameters (type Q).
+[x[_]] => x[Double]'s type parameters do not match type Q's expected parameters:
+type x has one type parameter, but type _ has none
+  qux[[x[_]] => x[Double]]
+     ^
+typelambda2.scala:6: error: [x, y] => x => y takes two type parameters, expected: one
+  qux[[x, y] => (x => y)]
+      ^
+typelambda2.scala:7: error: not found: type x
+  qux[x => y]
+      ^
+typelambda2.scala:7: error: not found: type y
+  qux[x => y]
+           ^
+typelambda2.scala:7: error: <error> => <error> takes no type parameters, expected: one
+  qux[x => y]
+        ^
+5 errors found

test/files/neg/typelambda2.scala

@@ -0,0 +1,8 @@
+object Test {
+
+  def qux[Q[_]] = 999
+
+  qux[[x[_]] => x[Double]]
+  qux[[x, y] => (x => y)]
+  qux[x => y]
+}

test/files/pos/typelambda.scala

@@ -0,0 +1,27 @@
+trait Monad[M[_]] {
+  def point[A](a: A): M[A]
+  def bind[A, B](ma: M[A])(f: A => M[B]): M[B]
+}
+
+object Test {
+  trait RightMonad[L] extends Monad[[x] => Either[L, x]] {
+    def point[A](a: A): Either[L, A] =
+      Right(a)
+    def bind[A, B](ma: Either[L, A])(f: A => Either[L, B]): Either[L, B] =
+      ma.right.flatMap(f)
+  }
+
+  def test1[A[_]] = 999
+
+  test1[[a] => (a, a)]
+  test1[[b] => Unit]
+  test1[[x] => x => x]
+  test1[[y] => Option[y]]
+  test1[[z] => Map[z, Set[z]]]
+
+  def test2[X[_[_]]] = 999
+
+  test2[[abc[_]] => abc[Int]]
+  test2[[xyz[_]] => xyz[xyz[xyz[Unit]]]]
+  test2[[q[_]] => Monad[q]]
+}