Check for illegal wildcards in TypeAssigner

Drop previous checking in Parser. The idea is that the parser should
follow the syntax. Checking conditions that are not reflected in the
syntax should come later.

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -153,6 +153,11 @@ class Definitions {
     sym
   }
 
+  private def enterBinaryAlias(name: TypeName, op: (Type, Type) => Type): TypeSymbol =
+    enterAliasType(name,
+      HKTypeLambda(TypeBounds.empty :: TypeBounds.empty :: Nil)(
+      tl => op(tl.paramRefs(0), tl.paramRefs(1))))
+
   private def enterPolyMethod(cls: ClassSymbol, name: TermName, typeParamCount: Int,
                     resultTypeFn: PolyType => Type, flags: FlagSet = EmptyFlags,
                     useCompleter: Boolean = false) = {
@@ -322,6 +327,9 @@ class Definitions {
   }
   def AnyKindType: TypeRef = AnyKindClass.typeRef
 
+  lazy val andType: TypeSymbol = enterBinaryAlias(tpnme.AND, AndType(_, _))
+  lazy val orType: TypeSymbol = enterBinaryAlias(tpnme.OR, OrType(_, _))
+
   /** Marker method to indicate an argument to a call-by-name parameter.
    *  Created by byNameClosures and elimByName, eliminated by Erasure,
    */
@@ -1326,6 +1334,8 @@ class Definitions {
     AnyClass,
     AnyRefAlias,
     AnyKindClass,
+    andType,
+    orType,
     RepeatedParamClass,
     ByNameParamClass2x,
     AnyValClass,

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

@@ -492,9 +492,9 @@ object Parsers {
                 val l = opInfo.operand
                 val r = top
                 if (isType && !op.isBackquoted && op.name == tpnme.raw.BAR) {
-                  OrTypeTree(checkAndOrArgument(l), checkAndOrArgument(r))
+                  OrTypeTree(l, r)
                 } else if (isType && !op.isBackquoted && op.name == tpnme.raw.AMP) {
-                  AndTypeTree(checkAndOrArgument(l), checkAndOrArgument(r))
+                  AndTypeTree(l, r)
                 } else
                   InfixOp(l, op, r)
               }
@@ -830,7 +830,7 @@ object Parsers {
                       t
                   }
                 }
-              val tuple = atSpan(start) { makeTupleOrParens(ts) }
+              val tuple = atSpan(start) { makeTupleOrParens(ts1) }
               infixTypeRest(
                 refinedTypeRest(
                   withTypeRest(
@@ -898,7 +898,7 @@ object Parsers {
         if (ctx.settings.strict.value)
           deprecationWarning(DeprecatedWithOperator())
         in.nextToken()
-        AndTypeTree(checkAndOrArgument(t), checkAndOrArgument(withType()))
+        AndTypeTree(t, withType())
       }
       else t
 
@@ -1091,19 +1091,6 @@ object Parsers {
       else
         rejectWildcard(t, fallbackTree)
 
-    def checkAndOrArgument(t: Tree): Tree =
-      findNonValueTypeTree(t, true) match {
-        case Some(typTree) =>
-          typTree match {
-            case typTree: TypeBoundsTree =>
-              syntaxError(UnboundWildcardType(), typTree.span)
-            case typTree: ByNameTypeTree =>
-              syntaxError(ByNameParameterNotSupported(typTree), typTree.span)
-          }
-          scalaAny
-        case None => t
-      }
-
 /* ----------- EXPRESSIONS ------------------------------------------------ */
 
     /** EqualsExpr ::= `=' Expr

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

@@ -92,6 +92,11 @@ object Checking {
     checkValidIfApply(ctx.addMode(Mode.AllowLambdaWildcardApply))
   }
 
+  def checkNoWildcard(tree: Tree)(implicit ctx: Context): Tree = tree.tpe match {
+    case tpe: TypeBounds => errorTree(tree, "no wildcard type allowed here")
+    case _ => tree
+  }
+
   /** Check that kind of `arg` has the same outline as the kind of paramBounds.
    *  E.g. if `paramBounds` has kind * -> *, `arg` must have that kind as well,
    *  and analogously for all other kinds. This kind checking does not take into account

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

@@ -13,7 +13,7 @@ import ast.Trees._
 import NameOps._
 import collection.mutable
 import reporting.diagnostic.messages._
-import Checking.checkNoPrivateLeaks
+import Checking.{checkNoPrivateLeaks, checkNoWildcard}
 
 trait TypeAssigner {
   import tpd._
@@ -519,10 +519,10 @@ trait TypeAssigner {
     tree.withType(ref.tpe)
 
   def assignType(tree: untpd.AndTypeTree, left: Tree, right: Tree)(implicit ctx: Context): AndTypeTree =
-    tree.withType(AndType(left.tpe, right.tpe))
+    tree.withType(AndType(checkNoWildcard(left).tpe, checkNoWildcard(right).tpe))
 
   def assignType(tree: untpd.OrTypeTree, left: Tree, right: Tree)(implicit ctx: Context): OrTypeTree =
-    tree.withType(OrType(left.tpe, right.tpe))
+    tree.withType(OrType(checkNoWildcard(left).tpe, checkNoWildcard(right).tpe))
 
   /** Assign type of RefinedType.
    *  Refinements are typed as if they were members of refinement class `refineCls`.

tests/neg/i4373.scala

@@ -41,8 +41,8 @@ object Test {
 
   type T19 = (_ with Int) @ annotation.tailrec // error
   type T20 = (Int with _) @ annotation.tailrec // error
-  type T21 = Int @ (_ with annotation.tailrec) // error // error
-  type T22 = Int @ (annotation.tailrec with _) // error // error
+  type T21 = Int @ (_ with annotation.tailrec) // error
+  type T22 = Int @ (annotation.tailrec with _) // error
 
   type T23 = (_ & Int) @ annotation.tailrec // error
   type T24 = (Int & _) @ annotation.tailrec // error