Fix scala#4373: reject wildcard types in syntactically invalid positions

Fix scala#4373.

The testcase is from examples in scala#4373, variations and tests for types
with wildcards. I'm unsure for a couple cases.

Author: Blaisorblade

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

@@ -892,6 +892,9 @@ object desugar {
       .withMods(mods)
       .withPos(original.pos.withPoint(named.pos.start))
 
+  def checkWildcard(t: Tree)(implicit ctx: Context): Tree =
+    parsing.Parsers.rejectWildcard(t, ctx.error(UnboundWildcardType(), _), scalaAny)
+
   /** Main desugaring method */
   def apply(tree: Tree)(implicit ctx: Context): Tree = {
 
@@ -1114,8 +1117,8 @@ object desugar {
         Apply(Select(Apply(Ident(nme.StringContext), strs), id), elems)
       case InfixOp(l, op, r) =>
         if (ctx.mode is Mode.Type)
-          if (!op.isBackquoted && op.name == tpnme.raw.AMP) AndTypeTree(l, r)     // l & r
-          else if (!op.isBackquoted && op.name == tpnme.raw.BAR) OrTypeTree(l, r) // l | r
+          if (!op.isBackquoted && op.name == tpnme.raw.AMP) AndTypeTree(checkWildcard(l), checkWildcard(r))     // l & r
+          else if (!op.isBackquoted && op.name == tpnme.raw.BAR) OrTypeTree(checkWildcard(l), checkWildcard(r)) // l | r
           else AppliedTypeTree(op, l :: r :: Nil) // op[l, r]
         else {
           assert(ctx.mode is Mode.Pattern) // expressions are handled separately by `binop`

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

@@ -795,7 +795,7 @@ object Parsers {
           val start = in.offset
           val tparams = typeParamClause(ParamOwner.TypeParam)
           if (in.token == ARROW)
-            atPos(start, in.skipToken())(LambdaTypeTree(tparams, typ()))
+            atPos(start, in.skipToken())(LambdaTypeTree(tparams, toplevelTyp()))
           else { accept(ARROW); typ() }
         }
         else infixType()
@@ -833,7 +833,7 @@ object Parsers {
 
     def refinedTypeRest(t: Tree): Tree = {
       newLineOptWhenFollowedBy(LBRACE)
-      if (in.token == LBRACE) refinedTypeRest(atPos(startOffset(t)) { RefinedTypeTree(t, refinement()) })
+      if (in.token == LBRACE) refinedTypeRest(atPos(startOffset(t)) { RefinedTypeTree(checkWildcard(t), refinement()) })
       else t
     }
 
@@ -897,7 +897,7 @@ object Parsers {
     private def simpleTypeRest(t: Tree): Tree = in.token match {
       case HASH => simpleTypeRest(typeProjection(t))
       case LBRACKET => simpleTypeRest(atPos(startOffset(t)) {
-        AppliedTypeTree(t, typeArgs(namedOK = false, wildOK = true)) })
+        AppliedTypeTree(checkWildcard(t), typeArgs(namedOK = false, wildOK = true)) })
       case _ => t
     }
 
@@ -2151,7 +2151,7 @@ object Parsers {
         in.token match {
           case EQUALS =>
             in.nextToken()
-            TypeDef(name, lambdaAbstract(tparams, typ())).withMods(mods).setComment(in.getDocComment(start))
+            TypeDef(name, lambdaAbstract(tparams, toplevelTyp())).withMods(mods).setComment(in.getDocComment(start))
           case SUPERTYPE | SUBTYPE | SEMI | NEWLINE | NEWLINES | COMMA | RBRACE | EOF =>
             TypeDef(name, lambdaAbstract(tparams, typeBounds())).withMods(mods).setComment(in.getDocComment(start))
           case _ =>
@@ -2279,7 +2279,7 @@ object Parsers {
     /** ConstrApp         ::=  SimpleType {ParArgumentExprs}
      */
     val constrApp = () => {
-      val t = annotType()
+      val t = checkWildcard(annotType())
       if (in.token == LPAREN) parArgumentExprss(wrapNew(t))
       else t
     }

tests/neg/i4373.scala

@@ -0,0 +1,23 @@
+trait Base
+trait TypeConstr[X]
+
+class X1[A >: _ | X1[_]] // error
+class X2[A >: _ & X2[_]] // error
+class X3[A >: X3[_] | _] // error
+class X4[A >: X4[_] & _] // error
+
+class A1 extends _ // error
+class A2 extends _ with _ // error // error
+class A3 extends Base with _ // error
+class A4 extends _ with Base // error
+
+object Test {
+  type T1 = _ // error
+  type T2 = _[Int] // error
+  type T3 = _ { type S } // error
+  type T4 = [X] => _ // error
+
+  // Open questions:
+  type T5 = TypeConstr[_ { type S }] // error
+  type T5 = TypeConstr[_[Int]] // error
+}