Disallow curried type methods

Curried type methods open the possibility of partial applications. But this
would give us full dependent typing, with types containing arbitrary terms
(namely the arguments of the partial application).

Author: odersky

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

@@ -2200,7 +2200,7 @@ object Parsers {
         Block(stats, Literal(Constant(())))
       }
 
-    /** TypeDcl  ::=  id [TypTypeParamClause] {DefParamClause} TypeBounds ‘=’ TypeRHS
+    /** TypeDcl  ::=  id [TypTypeParamClause] [DefParamClause] TypeBounds ‘=’ TypeRHS
      *             |  id [HkTypeParamClause] TypeBounds
      */
     def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = {
@@ -2209,6 +2209,7 @@ object Parsers {
         val name = ident().toTypeName
         val tparams = typeParamClauseOpt(ParamOwner.Type)
         val vparamss = paramClauses(ParamOwner.Type)
+        if (vparamss.length > 1) syntaxError(i"type definitions cannot have multiple parameter clauses")
         val isBounded = in.token == SUPERTYPE || in.token == SUBTYPE
         val bounds = typeBounds()
         val res =

docs/docs/internals/syntax.md

@@ -313,7 +313,7 @@ ValDcl            ::=  ids ‘:’ Type
 VarDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 DefDcl            ::=  DefSig [‘:’ Type]                                        DefDef(_, name, tparams, vparamss, tpe, EmptyTree)
 DefSig            ::=  id [DefTypeParamClause] DefParamClauses
-TypeDcl           ::=  id [TypTypeParamClause] {DefParamClause} TypeBounds      DefDef(name, tparams, vparamss, bounds, rhs)
+TypeDcl           ::=  id [TypTypeParamClause] [DefParamClause] TypeBounds      DefDef(name, tparams, vparamss, bounds, rhs)
                        ‘=’ TypeRHS
                     |  id [HkTypeParamClause] TypeBounds                        TypeDef(name, tparams, bounds)
 

tests/neg/typemethods.scala

@@ -17,4 +17,9 @@ object Test extends App {
     else S[ToNat(n - 1)]
 
   type ToNat = Int  // error: double definition
+
+  type Foo[T](n: Int)(m: Int) = Int // error: cannot be curried
+
+  type Bar(implicit m: Int) = Int // error: cannot be implicit
+  type Baz(erased m: Int) = Int // error: cannot be erased
 }