Drop named type parameters in classes

Drop the [type T] syntax, and what's associated to make it work.

Motivation: It's an alternative way of doing things for which there seems
to be little need. The implementation was provisional and bitrotted during
the various iterations to introduce higher-kinded types. So in the end the
complxity-cost for language and compiler was not worth the added benefit
that [type T] parameters provide.

Noe that we still accept _named arguments_ [A = T] in expressions; these are useful
for specifying some parameters and letting others be inferred.

1 files changed, 14 insertions, 16 deletions

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 57e3c1b88..b2e9d639d 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1064,23 +1064,21 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
     else {
       var args = tree.args
-      val args1 =
-        if (hasNamedArg(args)) typedNamedArgs(args)
-        else {
-          if (args.length != tparams.length) {
-            wrongNumberOfTypeArgs(tpt1.tpe, tparams, args, tree.pos)
-            args = args.take(tparams.length)
-          }
-          def typedArg(arg: untpd.Tree, tparam: TypeParamInfo) = {
-            val (desugaredArg, argPt) =
-              if (ctx.mode is Mode.Pattern)
-                (if (isVarPattern(arg)) desugar.patternVar(arg) else arg, tparam.paramBounds)
-              else
-                (arg, WildcardType)
-            typed(desugaredArg, argPt)
-          }
-          args.zipWithConserve(tparams)(typedArg(_, _)).asInstanceOf[List[Tree]]
+      val args1 = {
+        if (args.length != tparams.length) {
+          wrongNumberOfTypeArgs(tpt1.tpe, tparams, args, tree.pos)
+          args = args.take(tparams.length)
+        }
+        def typedArg(arg: untpd.Tree, tparam: TypeParamInfo) = {
+          val (desugaredArg, argPt) =
+            if (ctx.mode is Mode.Pattern)
+              (if (isVarPattern(arg)) desugar.patternVar(arg) else arg, tparam.paramBounds)
+            else
+              (arg, WildcardType)
+          typed(desugaredArg, argPt)
         }
+        args.zipWithConserve(tparams)(typedArg(_, _)).asInstanceOf[List[Tree]]
+      }
       // check that arguments conform to bounds is done in phase PostTyper
       assignType(cpy.AppliedTypeTree(tree)(tpt1, args1), tpt1, args1)
     }