Disallow unapplied types in aliases and bounds

It's the same as scalac in this respect.

Eearly on, we allowed aliases such as
```
type L = List
```
since we treated type parameters as type members, and higher-kinded
types as existential types. This is no longer the case. So the original
motivation for this is gone.

Furthermore, such higher-kinded aliases and bounds tend to make code
more obscure since the kind of a type is no longer obvious. They also
tend to exploit lots of dark corners in the compiler, where we do not
guard properly or early enough against kind-incorrectness. So the restricted
system is both safer and leads to clearer code.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -243,15 +243,15 @@ object Trees {
   // ------ Categories of trees -----------------------------------
 
   /** Instances of this class are trees for which isType is definitely true.
-   *  Note that some trees have isType = true without being TypTrees (e.g. Ident, AnnotatedTree)
+   *  Note that some trees have isType = true without being TypTrees (e.g. Ident, Annotated)
    */
   trait TypTree[-T >: Untyped] extends Tree[T] {
     type ThisTree[-T >: Untyped] <: TypTree[T]
     override def isType: Boolean = true
   }
 
   /** Instances of this class are trees for which isTerm is definitely true.
-   *  Note that some trees have isTerm = true without being TermTrees (e.g. Ident, AnnotatedTree)
+   *  Note that some trees have isTerm = true without being TermTrees (e.g. Ident, Annotated)
    */
   trait TermTree[-T >: Untyped] extends Tree[T] {
     type ThisTree[-T >: Untyped] <: TermTree[T]

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -1086,6 +1086,22 @@ trait Checking {
     checker.traverse(tree)
   }
 
+  /** Check that user-defined (result) type is fully applied */
+  def checkFullyAppliedType(tree: Tree)(using Context): Unit = tree match
+    case TypeBoundsTree(lo, hi, alias) =>
+      checkFullyAppliedType(lo)
+      checkFullyAppliedType(hi)
+      checkFullyAppliedType(alias)
+    case Annotated(arg, annot) =>
+      checkFullyAppliedType(arg)
+    case LambdaTypeTree(_, body) =>
+      checkFullyAppliedType(body)
+    case _: TypeTree =>
+    case _ =>
+      if tree.tpe.typeParams.nonEmpty then
+        val what = if tree.symbol.exists then tree.symbol else i"type $tree"
+        ctx.error(em"$what takes type parameters", tree.sourcePos)
+
   /** Check that we are in an inline context (inside an inline method or in inline code) */
   def checkInInlineContext(what: String, posd: Positioned)(using Context): Unit =
     if !Inliner.inInlineMethod && !ctx.isInlineContext then
@@ -1209,6 +1225,7 @@ trait ReChecking extends Checking {
   import tpd._
   override def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(using Context): Unit = ()
   override def checkRefsLegal(tree: tpd.Tree, badOwner: Symbol, allowed: (Name, Symbol) => Boolean, where: String)(using Context): Unit = ()
+  override def checkFullyAppliedType(tree: Tree)(using Context): Unit = ()
   override def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(using Context): Unit = ()
   override def checkAnnotApplicable(annot: Tree, sym: Symbol)(using Context): Boolean = true
 }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1664,13 +1664,16 @@ class Typer extends Namer
     }
   }
 
-  def typedLambdaTypeTree(tree: untpd.LambdaTypeTree)(using Context): Tree = {
+  private def typeIndexedLambdaTypeTree(
+      tree: untpd.LambdaTypeTree, tparams: List[untpd.TypeDef], body: untpd.Tree)(using Context) =
+    val tparams1 = tparams.map(typed(_)).asInstanceOf[List[TypeDef]]
+    val body1 = typedType(body)
+    assignType(cpy.LambdaTypeTree(tree)(tparams1, body1), tparams1, body1)
+
+  def typedLambdaTypeTree(tree: untpd.LambdaTypeTree)(using Context): Tree =
     val LambdaTypeTree(tparams, body) = tree
     index(tparams)
-    val tparams1 = tparams.mapconserve(typed(_).asInstanceOf[TypeDef])
-    val body1 = typedType(tree.body)
-    assignType(cpy.LambdaTypeTree(tree)(tparams1, body1), tparams1, body1)
-  }
+    typeIndexedLambdaTypeTree(tree, tparams, body)
 
   def typedTermLambdaTypeTree(tree: untpd.TermLambdaTypeTree)(using Context): Tree =
     if dependentEnabled then
@@ -1923,14 +1926,12 @@ class Typer extends Namer
   def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree = {
     val TypeDef(name, rhs) = tdef
     completeAnnotations(tdef, sym)
-    val rhs1 = tdef.rhs match {
+    val rhs1 = tdef.rhs match
       case rhs @ LambdaTypeTree(tparams, body) =>
-        val tparams1 = tparams.map(typed(_)).asInstanceOf[List[TypeDef]]
-        val body1 = typedType(body)
-        assignType(cpy.LambdaTypeTree(rhs)(tparams1, body1), tparams1, body1)
+        typeIndexedLambdaTypeTree(rhs, tparams, body)
       case rhs =>
         typedType(rhs)
-    }
+    checkFullyAppliedType(rhs1)
     assignType(cpy.TypeDef(tdef)(name, rhs1), sym)
   }
 

tests/neg/i4557.scala

@@ -2,11 +2,11 @@ class C0[A]
 class C1[A, B]
 
 object O {
-  type T0 = C0
+  type T0[X] = C0[X]
   type T1 = C0[String, Int] // error
   type T2[A] = C0[A, Int] // error
 
-  type S0 = C1
+  type S0[X, Y] = C1[X, Y]
   type S1 = C1[Int] // error
 
   class D0 extends T0 // error

tests/neg/i7820.scala

@@ -1,3 +1,3 @@
 trait A1 { type F[X <: F[_, _], Y] }  // error: cyclic reference involving type F
-trait A2 { type F[X <: F, Y] }        // error: cyclic reference involving type F
-trait A3 { type F[X >: F, Y] }        // error: cyclic reference involving type F
+trait A2 { type F[X <: F, Y] }        // error: cyclic reference involving type F // error
+trait A3 { type F[X >: F, Y] }        // error: cyclic reference involving type F // error

tests/neg/multi-param-derives.scala

@@ -27,7 +27,7 @@ object Test extends App {
       given t2 [T] as Functor[[U] =>> (T, U)] {}
       given t3 [T, U] as Functor[[V] =>> (T, U, V)] {}
 
-      def derived[F[_]](using m: Mirror { type MirroredType = F ; type MirroredElemTypes[_] }, r: Functor[m.MirroredElemTypes]): Functor[F] = new Functor[F] {}
+      def derived[F[_]](using m: Mirror { type MirroredType[X] = F[X] ; type MirroredElemTypes[_] }, r: Functor[m.MirroredElemTypes]): Functor[F] = new Functor[F] {}
     }
 
     case class Mono(i: Int) derives Functor
@@ -43,7 +43,7 @@ object Test extends App {
       given [C] as FunctorK[[F[_]] =>> C] {}
       given [T] as FunctorK[[F[_]] =>> Tuple1[F[T]]]
 
-      def derived[F[_[_]]](using m: Mirror { type MirroredType = F ; type MirroredElemTypes[_[_]] }, r: FunctorK[m.MirroredElemTypes]): FunctorK[F] = new FunctorK[F] {}
+      def derived[F[_[_]]](using m: Mirror { type MirroredType[X[_]] = F[X] ; type MirroredElemTypes[_[_]] }, r: FunctorK[m.MirroredElemTypes]): FunctorK[F] = new FunctorK[F] {}
     }
 
     case class Mono(i: Int) derives FunctorK
@@ -61,7 +61,7 @@ object Test extends App {
       given t2 as Bifunctor[[T, U] =>> (T, U)] {}
       given t3 [T] as Bifunctor[[U, V] =>> (T, U, V)] {}
 
-      def derived[F[_, _]](using m: Mirror { type MirroredType = F ; type MirroredElemTypes[_, _] }, r: Bifunctor[m.MirroredElemTypes]): Bifunctor[F] = ???
+      def derived[F[_, _]](using m: Mirror { type MirroredType[X, Y] = F[X, Y] ; type MirroredElemTypes[_, _] }, r: Bifunctor[m.MirroredElemTypes]): Bifunctor[F] = ???
     }
 
     case class Mono(i: Int) derives Bifunctor

tests/neg/parser-stability-12.scala

@@ -1,4 +1,4 @@
 trait x0[]:  // error
-     trait x1[x1 <:x0]
+     trait x1[x1 <:x0] // error: type x0 takes type parameters
      extends x1[  // error
 // error

tests/neg/unapplied-types.scala

@@ -0,0 +1,7 @@
+trait T {
+  type L[X] = List[X]
+  type T1 <: L    // error: takes type parameters
+  type T2 = L     // error: takes type parameters
+  type T3 = List  // error: takes type parameters
+  type T4 <: List // error: takes type parameters
+}

tests/pos-macros/i6588.scala

@@ -15,7 +15,7 @@ def main(using QuoteContext) = {
   foo[U]
   foo[List[Int]]
 
-  type N = List
+  type N[+X] = List[X]
   foo[N]
   foo[List]
 

tests/pos/X.scala

@@ -1,14 +1,10 @@
-abstract class A() {
+import scala.deriving._
 
-  var x: Int
+trait FunctorK[F[_[_]]]
+object FunctorK {
+  given [C] as FunctorK[[F[_]] =>> C] {}
+  given [T] as FunctorK[[F[_]] =>> Tuple1[F[T]]]
 
-}
-
-abstract class B() extends A() {
-
-  var xx: Int = 0;
-
-  def x = xx;
-  def x_=(y: Int) = xx = y;
+  def derived[F[_[_]]](using m: Mirror { type MirroredType[X[_]] = F[X] ; type MirroredElemTypes[_[_]] }, r: FunctorK[m.MirroredElemTypes]): FunctorK[F] = new FunctorK[F] {}
 }
 

tests/pos/hk-subtyping.scala

@@ -5,7 +5,7 @@ object Test {
   compare[Int, Int]
   compare[Int, Any]
 
-  def f[C <: List] = {
+  def f[C <: [X] =>> List[X]] = {
     compare[C[Int], List[Int]]
   }
 

tests/pos/i2232.scala

@@ -8,15 +8,15 @@ object Cats {
     [A, B] =>> C[({type l[c0[_], c1[_, _]] = c1[A, B]})#l]
 
   trait Category[C[_[_[_], _[_, _]]]] {
-    type ->  = Cats.Cat[C]
-    type Obj = Cats.Obj[C]
+    type -> [X, Y] = Cats.Cat[C][X, Y]
+    type Obj[X] = Cats.Obj[C][X]
 
     def id[A: Obj]: A -> A
     def andThen[A, B, C](ab: A -> B, bc: B -> C): A -> C
   }
 
   object Category {
-    type ByF[F[_, _]] = Category[_] { type -> = F }
+    type ByF[F[_, _]] = Category[_] { type -> [X, Y] = F[X, Y] }
   }
 
   type Scal[f[_[_], _[_, _]]] = f[Trivial, Function1]
@@ -28,10 +28,10 @@ object Cats {
 
   implicit class CategoryOps[F[_, _], A, B](ab: F[A, B]) {
     def >>>[C](bc: F[B, C])(implicit F: Category.ByF[F]): F[A, C] =
-      F.andThen(ab, bc)
+      ??? // F.andThen(ab, bc)  -- disabled since it does not typecheck
   }
 
   val f: Int => Int = _ + 1
   val g: Int => String = _.toString
-  f >>> g   // error: no implicit arg found
+  f >>> g
 }

tests/pos/i3139.scala

@@ -5,7 +5,3 @@ trait Foo[T] {
 object Test {
   def foo[T](ev: Foo[T]): Foo[T] { type Base[A] = ev.Base[A] } = ev
 }
-
-object Test2 {
-  def foo[T](ev: Foo[T]): Foo[T] { type Base = ev.Base } = ev
-}

tests/pos/i3658.scala

@@ -2,7 +2,7 @@ object App {
   def main(args: Array[String]): Unit = {
     trait ModuleSig {
       type F[_]
-      type Type = F
+      type Type[X] = F[X]
 
       def subst[F[_[_]]](fa: F[List]): F[Type]
     }

tests/pos/i5574.scala

@@ -6,7 +6,7 @@ object i5574 {
   transparent inline def foo[T]: Any =
     inline erasedValue[T] match {
       case _: Box[f] =>
-        type t = f
+        type t[X] = f[X]
         23
     }
 

tests/pos/i6014-gadt.scala

@@ -31,7 +31,7 @@ object Test3 {
 
   type K1Top = [t] =>> Any
 
-  class Foo[F <: K1Top]
+  class Foo[F[X] <: K1Top[X]]
 
   inline def bar[T] = inline erasedValue[T] match {
     case _: Foo[f] => summon[f[Int]]

tests/pos/i6159.scala

@@ -3,7 +3,7 @@ trait B extends A
 
 object O {
   opaque type T[X <: A] = X
-  type U = T.U
+  type U[X <: A] = T.U[X]
   object T{
     type U[X <: A] = X
     def t(a: T[B]): T[B] = a

tests/pos/i7219.scala

@@ -24,8 +24,8 @@ object Test {
     def x6: D[Int] = D()
   }
   export Types._
-  type D1 = Types.D
-  type U1 = Types.UC
+  type D1[X] = Types.D[X]
+  type U1[X] = Types.UC[X]
 
   val y1: T = x1
   val y2: U = x2

tests/pos/mirror-implicit-scope.scala

@@ -9,7 +9,7 @@ object Test {
   }
 
   object K1 {
-    type Generic[F[_]] = Mirror { type Scope = K1.type ; type MirroredType = F ; type MirroredElemTypes[_] }
+    type Generic[F[_]] = Mirror { type Scope = K1.type ; type MirroredType = [X] =>> F[X] ; type MirroredElemTypes[_] }
     extension on [F[_] <: Product, T](gen: Generic[F]) {
       inline def toRepr (t: F[T]): gen.MirroredElemTypes[T] = Tuple.fromProduct(t).asInstanceOf
     }

tests/pos/opaque-groups.scala

@@ -32,7 +32,7 @@ package object groups {
 
   opaque type First[A] = A
   object First extends Wrapper {
-    type F = First
+    type F[A] = First[A]
     def wraps[G[_], A](ga: G[A]): G[First[A]] = ga
     def unwrap[G[_], A](gfa: G[First[A]]): G[A] = gfa
     implicit def firstSemigroup[A]: Semigroup[First[A]] =
@@ -41,7 +41,7 @@ package object groups {
 
   opaque type Last[A] = A
   object Last extends Wrapper {
-    type F = Last
+    type F[A] = Last[A]
     def wraps[G[_], A](ga: G[A]): G[Last[A]] = ga
     def unwrap[G[_], A](gfa: G[Last[A]]): G[A] = gfa
     implicit def lastSemigroup[A]: Semigroup[Last[A]] =
@@ -50,7 +50,7 @@ package object groups {
 
   opaque type Min[A] = A
   object Min extends Wrapper {
-    type F = Min
+    type F[A] = Min[A]
     def wraps[G[_], A](ga: G[A]): G[Min[A]] = ga
     def unwrap[G[_], A](gfa: G[Min[A]]): G[A] = gfa
     implicit def minSemigroup[A](implicit o: Ordering[A]): Semigroup[Min[A]] =
@@ -59,7 +59,7 @@ package object groups {
 
   opaque type Max[A] = A
   object Max extends Wrapper {
-    type F = Max
+    type F[A] = Max[A]
     def wraps[G[_], A](ga: G[A]): G[Max[A]] = ga
     def unwrap[G[_], A](gfa: G[Max[A]]): G[A] = gfa
     implicit def maxSemigroup[A](implicit o: Ordering[A]): Semigroup[Max[A]] =
@@ -68,7 +68,7 @@ package object groups {
 
   opaque type Plus[A] = A
   object Plus extends Wrapper {
-    type F = Plus
+    type F[A] = Plus[A]
     def wraps[G[_], A](ga: G[A]): G[Plus[A]] = ga
     def unwrap[G[_], A](gfa: G[Plus[A]]): G[A] = gfa
     implicit def plusSemigroup[A](implicit n: Numeric[A]): Semigroup[Plus[A]] =
@@ -77,7 +77,7 @@ package object groups {
 
   opaque type Times[A] = A
   object Times extends Wrapper {
-    type F = Times
+    type F[A] = Times[A]
     def wraps[G[_], A](ga: G[A]): G[Times[A]] = ga
     def unwrap[G[_], A](gfa: G[Times[A]]): G[A] = gfa
     implicit def timesSemigroup[A](implicit n: Numeric[A]): Semigroup[Times[A]] =
@@ -86,7 +86,7 @@ package object groups {
 
   opaque type Reversed[A] = A
   object Reversed extends Wrapper {
-    type F = Reversed
+    type F[A] = Reversed[A]
     def wraps[G[_], A](ga: G[A]): G[Reversed[A]] = ga
     def unwrap[G[_], A](gfa: G[Reversed[A]]): G[A] = gfa
     implicit def reversedOrdering[A](implicit o: Ordering[A]): Ordering[Reversed[A]] =
@@ -95,7 +95,7 @@ package object groups {
 
   opaque type Unordered[A] = A
   object Unordered extends Wrapper {
-    type F = Unordered
+    type F[A] = Unordered[A]
     def wraps[G[_], A](ga: G[A]): G[Unordered[A]] = ga
     def unwrap[G[_], A](gfa: G[Unordered[A]]): G[A] = gfa
     implicit def unorderedOrdering[A]: Ordering[Unordered[A]] =

tests/pos/polyalias.scala

@@ -1,7 +1,7 @@
 
 object Test {
 
-  type S = scala.Predef.Set
+  type S[X] = scala.Predef.Set[X]
 
   val z: S[_] = ???