Drop restriction against typedefs at level * only

Allow the RHS of a type def to be higher-kinded. But keep the
restriction for opaque type aliases; their RHS must be fully applied.
I am not sure why the restriction applies to them, but there was a
test specifically about that, so there night be a reason.

# Conflicts:
#	compiler/src/dotty/tools/dotc/typer/Typer.scala

# Conflicts:
#	compiler/src/dotty/tools/dotc/typer/Typer.scala
#	tests/pos/typeclasses-this.scala

Author: odersky

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

@@ -1325,20 +1325,20 @@ trait Checking {
   }
 
   /** Check that user-defined (result) type is fully applied */
-  def checkFullyAppliedType(tree: Tree)(using Context): Unit = tree match
+  def checkFullyAppliedType(tree: Tree, prefix: String)(using Context): Unit = tree match
     case TypeBoundsTree(lo, hi, alias) =>
-      checkFullyAppliedType(lo)
-      checkFullyAppliedType(hi)
-      checkFullyAppliedType(alias)
+      checkFullyAppliedType(lo, prefix)
+      checkFullyAppliedType(hi, prefix)
+      checkFullyAppliedType(alias, prefix)
     case Annotated(arg, annot) =>
-      checkFullyAppliedType(arg)
+      checkFullyAppliedType(arg, prefix)
     case LambdaTypeTree(_, body) =>
-      checkFullyAppliedType(body)
+      checkFullyAppliedType(body, prefix)
     case _: TypeTree =>
     case _ =>
       if tree.tpe.typeParams.nonEmpty then
         val what = if tree.symbol.exists then tree.symbol.show else i"type $tree"
-        report.error(em"$what takes type parameters", tree.srcPos)
+        report.error(em"$prefix$what takes type parameters", tree.srcPos)
 
   /** Check that we are in an inline context (inside an inline method or in inline code) */
   def checkInInlineContext(what: String, pos: SrcPos)(using Context): Unit =
@@ -1603,7 +1603,7 @@ trait ReChecking extends Checking {
   override def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Unit = ()
   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 checkFullyAppliedType(tree: Tree, prefix: String)(using Context): Unit = ()
   override def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(using Context): Unit = ()
   override def checkAnnotApplicable(annot: Tree, sym: Symbol)(using Context): Boolean = true
   override def checkMatchable(tp: Type, pos: SrcPos, pattern: Boolean)(using Context): Unit = ()

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

@@ -2704,8 +2704,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         typeIndexedLambdaTypeTree(rhs, tparams, body)
       case rhs =>
         typedType(rhs)
-    checkFullyAppliedType(rhs1)
-    if sym.isOpaqueAlias then checkNoContextFunctionType(rhs1)
+    if sym.isOpaqueAlias then
+      checkFullyAppliedType(rhs1, "Opaque type alias must be fully applied, but ")
+      checkNoContextFunctionType(rhs1)
     assignType(cpy.TypeDef(tdef)(name, rhs1), sym)
   }
 

tests/neg/i12456.scala

@@ -1 +1 @@
-object F { type T[G[X] <: X, F <: G[F]] } // error // error
+object F { type T[G[X] <: X, F <: G[F]] } // error

tests/neg/i13757-match-type-anykind.scala

@@ -8,7 +8,7 @@ object Test:
   type AnyKindMatchType3[X <: AnyKind] = X match // error: the scrutinee of a match type cannot be higher-kinded
     case _ => Int
 
-  type AnyKindMatchType4[X <: Option] = X match // error // error: the scrutinee of a match type cannot be higher-kinded
+  type AnyKindMatchType4[X <: Option] = X match // error: the scrutinee of a match type cannot be higher-kinded
     case _ => Int
 
   type AnyKindMatchType5[X[_]] = X match // error: the scrutinee of a match type cannot be higher-kinded

tests/neg/i9328.scala

@@ -3,7 +3,7 @@ type Id[T] = T match {
   case _ => T
 }
 
-class Foo2[T <: Id[T]] // error // error
+class Foo2[T <: Id[T]] // error
 
 object Foo { // error
   object Foo { }

tests/neg/parser-stability-12.scala

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

tests/neg/unapplied-types.scala

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