Get rid of bindingTree and ownerSym in TypeVars

Author: odersky

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

@@ -573,6 +573,11 @@ object Trees {
       s"TypeTree${if (hasType) s"[$typeOpt]" else ""}"
   }
 
+  /** A type tree that defines a new type variable. Its type is always a TypeVar.
+   *  Every TypeVar is created as the type of one TypeVarBinder.
+   */
+  class TypeVarBinder[-T >: Untyped] extends TypeTree
+
   /** ref.type */
   case class SingletonTypeTree[-T >: Untyped] private[ast] (ref: Tree[T])
     extends DenotingTree[T] with TypTree[T] {

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

@@ -3354,14 +3354,11 @@ object Types {
    *
    *  @param  origin        The parameter that's tracked by the type variable.
    *  @param  creatorState  The typer state in which the variable was created.
-   *  @param  bindingTree   The TypeTree which introduces the type variable, or EmptyTree
-   *                        if the type variable does not correspond to a source term.
-   *  @paran  owner         The current owner if the context where the variable was created.
    *
    *  `owningTree` and `owner` are used to determine whether a type-variable can be instantiated
    *  at some given point. See `Inferencing#interpolateUndetVars`.
    */
-  final class TypeVar(val origin: TypeParamRef, creatorState: TyperState, var bindingTree: untpd.Tree, val owner: Symbol) extends CachedProxyType with ValueType {
+  final class TypeVar(val origin: TypeParamRef, creatorState: TyperState) extends CachedProxyType with ValueType {
 
     /** The permanent instance type of the variable, or NoType is none is given yet */
     private[this] var myInst: Type = NoType

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

@@ -166,10 +166,9 @@ object Inferencing {
     @tailrec def boundVars(tree: Tree, acc: List[TypeVar]): List[TypeVar] = tree match {
       case Apply(fn, _) => boundVars(fn, acc)
       case TypeApply(fn, targs) =>
-        val tvars = targs.tpes.collect {
+        val tvars = targs.filter(_.isInstanceOf[TypeVarBinder[_]]).tpes.collect {
           case tvar: TypeVar
           if !tvar.isInstantiated &&
-             targs.contains(tvar.bindingTree) &&
              ctx.typerState.ownedVars.contains(tvar) &&
              !locked.contains(tvar) => tvar
         }

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

@@ -394,8 +394,8 @@ object ProtoTypes {
     def newTypeVars(tl: TypeLambda): List[TypeTree] =
       for (n <- (0 until tl.paramNames.length).toList)
       yield {
-        val tt = new TypeTree().withPos(owningTree.pos)
-        val tvar = new TypeVar(tl.paramRefs(n), state, tt, ctx.owner)
+        val tt = new TypeVarBinder().withPos(owningTree.pos)
+        val tvar = new TypeVar(tl.paramRefs(n), state)
         state.ownedVars += tvar
         tt.withType(tvar)
       }