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, 4 insertions, 10 deletions

diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index 308e6e306..6c40794e3 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -428,16 +428,10 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         case tp: TypeRef =>
           tp
         case tp @ RefinedType(tp1, name: TypeName, rinfo) =>
-          rinfo match {
-            case TypeAlias(TypeRef(pre, name1)) if name1 == name && (pre =:= cls.thisType) =>
-              // Don't record refinements of the form X = this.X (These can arise using named parameters).
-              typr.println(s"dropping refinement $tp")
-            case _ =>
-              val prevInfo = refinements(name)
-              refinements = refinements.updated(name,
-                if (prevInfo == null) tp.refinedInfo else prevInfo & tp.refinedInfo)
-              formals = formals.updated(name, tp1.typeParamNamed(name))
-          }
+          val prevInfo = refinements(name)
+          refinements = refinements.updated(name,
+            if (prevInfo == null) tp.refinedInfo else prevInfo & tp.refinedInfo)
+          formals = formals.updated(name, tp1.typeParamNamed(name))
           normalizeToRef(tp1)
         case _: ErrorType =>
           defn.AnyType