Treat wildcard args and pattern type variables the same

In a type pattern, a wildcard argument and a type variable needs to be treated the same.
I.e. it should make no difference if I have

    C[_ >: L <: H]

or

    C[t >: L <: H]

where `t` is unused. Previously, the two constructs had largely different codepaths with
different things that failed and worked. This fix is necessary to mitigate the fix for
scala#1754. The latter fix uncovered several problems with the way wildcard arguments in
patterns were treated.

The change also uncovered a problem in transforms: FirstTransform eliminates all type
nodes wnd with it any binders bound type symbols. This means that subsequently patVars
is wrong, and therefore a TreeTypeMap over a pattern will no longer duplicate pattern-
bound type variables. This caused Ycheck to fail after TailRec.

The fix is to keep pattern bound type variables around in an internal annotation, which
is understood by patVars.

Author: odersky

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

@@ -554,6 +554,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     val acc = new TreeAccumulator[List[Symbol]] {
       def apply(syms: List[Symbol], tree: Tree)(implicit ctx: Context) = tree match {
         case Bind(_, body) => apply(tree.symbol :: syms, body)
+        case Annotated(tree, id @ Ident(tpnme.BOUNDTYPE_ANNOT)) => apply(id.symbol :: syms, tree)
         case _ => foldOver(syms, tree)
       }
     }

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

@@ -143,6 +143,7 @@ object StdNames {
     val INITIALIZER_PREFIX: N         = "initial$"
     val COMPANION_MODULE_METHOD: N    = "companion$module"
     val COMPANION_CLASS_METHOD: N     = "companion$class"
+    val BOUNDTYPE_ANNOT: N            = "$boundType$"
     val QUOTE: N                      = "'"
     val TYPE_QUOTE: N                = "type_'"
     val TRAIT_SETTER_SEPARATOR: N     = str.TRAIT_SETTER_SEPARATOR

compiler/src/dotty/tools/dotc/transform/FirstTransform.scala

@@ -7,6 +7,7 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Phases.NeedsCompanions
 import dotty.tools.dotc.transform.MegaPhase._
 import ast.Trees._
+import ast.untpd
 import Flags._
 import Types._
 import Constants.Constant
@@ -188,8 +189,27 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =
     ast.Trees.flatten(reorderAndComplete(trees)(ctx.withPhase(thisPhase.next)))
 
-  private def toTypeTree(tree: Tree)(implicit ctx: Context) =
-    TypeTree(tree.tpe).withPos(tree.pos)
+  private object collectBinders extends TreeAccumulator[List[Ident]] {
+    def apply(annots: List[Ident], t: Tree)(implicit ctx: Context): List[Ident] = t match {
+      case t @ Bind(_, body) =>
+        val annot = untpd.Ident(tpnme.BOUNDTYPE_ANNOT).withType(t.symbol.typeRef)
+        apply(annot :: annots, body)
+      case _ =>
+        foldOver(annots, t)
+    }
+  }
+
+  /** Replace type tree `t` of type `T` with `TypeTree(T)`, but make sure all
+   *  binders in `t` are maintained by rewrapping binders around the type tree.
+   *  E.g. if `t` is  `C[t @ (>: L <: H)]`, replace with
+   *  `t @ TC[_ >: L <: H]`. The body of the binder `t` is now wrong, but this does
+   *  not matter, as we only need the info of `t`.
+   */
+  private def toTypeTree(tree: Tree)(implicit ctx: Context) = {
+    val binders = collectBinders.apply(Nil, tree)
+    val result: Tree = TypeTree(tree.tpe).withPos(tree.pos)
+    (result /: binders)(Annotated(_, _))
+  }
 
   override def transformOther(tree: Tree)(implicit ctx: Context) = tree match {
     case tree: Import => EmptyTree

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

@@ -554,8 +554,8 @@ class Typer extends Namer
       def typedTpt = checkSimpleKinded(typedType(tree.tpt))
       def handlePattern: Tree = {
         val tpt1 = typedTpt
-        // special case for an abstract type that comes with a class tag
         if (!ctx.isAfterTyper) tpt1.tpe.<:<(pt)(ctx.addMode(Mode.GADTflexible))
+        // special case for an abstract type that comes with a class tag
         tryWithClassTag(ascription(tpt1, isWildcard = true), pt)
       }
       cases(
@@ -998,37 +998,29 @@ class Typer extends Namer
       if (!gadtCtx.gadt.bounds.contains(sym))
         gadtCtx.gadt.setBounds(sym, TypeBounds.empty)
 
-    /** - replace all references to symbols associated with wildcards by their GADT bounds
+    /** - strip all instantiated TypeVars from pattern types.
+     *    run/reducable.scala is a test case that shows stripping typevars is necessary.
      *  - enter all symbols introduced by a Bind in current scope
      */
     val indexPattern = new TreeMap {
-      val elimWildcardSym = new TypeMap {
-        def apply(t: Type) = t match {
-          case ref: TypeRef if ref.name == tpnme.WILDCARD && gadtCtx.gadt.bounds.contains(ref.symbol) =>
-            gadtCtx.gadt.bounds(ref.symbol)
-          case TypeAlias(ref: TypeRef) if ref.name == tpnme.WILDCARD && gadtCtx.gadt.bounds.contains(ref.symbol) =>
-            gadtCtx.gadt.bounds(ref.symbol)
-          case _ =>
-            mapOver(t)
-        }
+      val stripTypeVars = new TypeMap {
+        def apply(t: Type) = mapOver(t)
       }
       override def transform(trt: Tree)(implicit ctx: Context) =
-        super.transform(trt.withType(elimWildcardSym(trt.tpe))) match {
+        super.transform(trt.withType(stripTypeVars(trt.tpe))) match {
           case b: Bind =>
             val sym = b.symbol
-            if (sym.exists) {
+            if (sym.name != tpnme.WILDCARD)
               if (ctx.scope.lookup(b.name) == NoSymbol) ctx.enter(sym)
               else ctx.error(new DuplicateBind(b, tree), b.pos)
-              sym.info = elimWildcardSym(sym.info)
-              b
-            }
-            else {
-              assert(b.name == tpnme.WILDCARD)
-              b.body
+            if (!ctx.isAfterTyper) {
+              val bounds = ctx.gadt.bounds(sym)
+              if (bounds != null) sym.info = bounds
             }
+            b
           case t => t
         }
-    }
+      }
 
     def caseRest(pat: Tree)(implicit ctx: Context) = {
       val pat1 = indexPattern.transform(pat)
@@ -1264,7 +1256,7 @@ class Typer extends Namer
     assignType(cpy.ByNameTypeTree(tree)(result1), result1)
   }
 
-  def typedTypeBoundsTree(tree: untpd.TypeBoundsTree)(implicit ctx: Context): Tree = track("typedTypeBoundsTree") {
+  def typedTypeBoundsTree(tree: untpd.TypeBoundsTree, pt: Type)(implicit ctx: Context): Tree = track("typedTypeBoundsTree") {
     val TypeBoundsTree(lo, hi) = tree
     val lo1 = typed(lo)
     val hi1 = typed(hi)
@@ -1279,8 +1271,12 @@ class Typer extends Namer
       // with an expected type in typedTyped. The type symbol and the defining Bind node
       // are eliminated once the enclosing pattern has been typechecked; see `indexPattern`
       // in `typedCase`.
-      val wildcardSym = ctx.newPatternBoundSymbol(tpnme.WILDCARD, tree1.tpe, tree.pos)
-      untpd.Bind(tpnme.WILDCARD, tree1).withType(wildcardSym.typeRef)
+      //val ptt = if (lo.isEmpty && hi.isEmpty) pt else
+      if (ctx.isAfterTyper) tree1
+      else {
+        val wildcardSym = ctx.newPatternBoundSymbol(tpnme.WILDCARD, tree1.tpe & pt, tree.pos)
+        untpd.Bind(tpnme.WILDCARD, tree1).withType(wildcardSym.typeRef)
+      }
     }
     else tree1
   }
@@ -1749,7 +1745,7 @@ class Typer extends Namer
           case tree: untpd.AppliedTypeTree => typedAppliedTypeTree(tree)
           case tree: untpd.LambdaTypeTree => typedLambdaTypeTree(tree)(localContext(tree, NoSymbol).setNewScope)
           case tree: untpd.ByNameTypeTree => typedByNameTypeTree(tree)
-          case tree: untpd.TypeBoundsTree => typedTypeBoundsTree(tree)
+          case tree: untpd.TypeBoundsTree => typedTypeBoundsTree(tree, pt)
           case tree: untpd.Alternative => typedAlternative(tree, pt)
           case tree: untpd.PackageDef => typedPackageDef(tree)
           case tree: untpd.Annotated => typedAnnotated(tree, pt)