Drop AppliedTypeTree

With the introduction of `Apply` nodes as types, we were facing an imbalance:
Type appications distinguished between type trees and term trees by having two
classes, `AppliedTypeTree` and `TypeApply`. Term applications did not. In the
interest of keeping the number of tree classes low, we now use `TypeApply for
both type and term trees that are applied to type tree arguments.

The only exception is in the Tasty format, where
we need to distinguish the two, because otherwise a hole followed by arguments
would be ambiguous. Distinguishing between terms and types in the Tasty serialization
format is done systematically everywhere. It has the advantage that it increases
redundancy. But for the internal tree representation it's better to have as few
classes as possible.

Author: odersky

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

@@ -357,7 +357,7 @@ object desugar {
     val classTycon: Tree = new TypeRefTree // watching is set at end of method
 
     def appliedTypeTree(tycon: Tree, args: List[Tree]) =
-      (if (args.isEmpty) tycon else AppliedTypeTree(tycon, args))
+      (if (args.isEmpty) tycon else TypeApply(tycon, args))
         .withPos(cdef.pos.startPos)
 
     def isHK(tparam: Tree): Boolean = tparam match {
@@ -371,7 +371,7 @@ object desugar {
         val targ = refOfDef(tparam)
         def fullyApplied(tparam: Tree): Tree = tparam match {
           case TypeDef(_, LambdaTypeTree(tparams, body)) =>
-            AppliedTypeTree(targ, tparams.map(_ => TypeBoundsTree(EmptyTree, EmptyTree)))
+            TypeApply(targ, tparams.map(_ => TypeBoundsTree(EmptyTree, EmptyTree)))
           case TypeDef(_, rhs: DerivedTypeTree) =>
             fullyApplied(rhs.watched)
           case _ =>
@@ -1113,7 +1113,7 @@ object desugar {
         Apply(Select(Apply(Ident(nme.StringContext), strs), id), elems)
       case InfixOp(l, op, r) =>
         if (ctx.mode is Mode.Type)
-          AppliedTypeTree(op, l :: r :: Nil) // op[l, r]
+          TypeApply(op, l :: r :: Nil) // op[l, r]
         else {
           assert(ctx.mode is Mode.Pattern) // expressions are handled separately by `binop`
           Apply(op, l :: r :: Nil) // op(l, r)
@@ -1122,7 +1122,7 @@ object desugar {
         if ((ctx.mode is Mode.Type) && !op.isBackquoted && op.name == tpnme.raw.STAR) {
           val seqType = if (ctx.compilationUnit.isJava) defn.ArrayType else defn.SeqType
           Annotated(
-            AppliedTypeTree(ref(seqType), t),
+            TypeApply(ref(seqType), t :: Nil),
             New(ref(defn.RepeatedAnnotType), Nil :: Nil))
         } else {
           assert(ctx.mode.isExpr || ctx.reporter.hasErrors || ctx.mode.is(Mode.Interactive), ctx.mode)
@@ -1138,7 +1138,7 @@ object desugar {
           ctx.error(TupleTooLong(ts), tree.pos)
           unitLiteral
         } else if (arity == 1) ts.head
-        else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts)
+        else if (ctx.mode is Mode.Type) TypeApply(ref(tupleTypeRef), ts)
         else if (arity == 0) unitLiteral
         else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
       case WhileDo(cond, body) =>

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

@@ -143,7 +143,7 @@ object DesugarEnums {
 
     def extractType(t: Tree): Tree = t match {
       case Apply(t1, _) => extractType(t1)
-      case TypeApply(t1, ts) => AppliedTypeTree(extractType(t1), ts)
+      case TypeApply(t1, ts) => TypeApply(extractType(t1), ts)
       case Select(t1, nme.CONSTRUCTOR) => extractType(t1)
       case New(t1) => t1
       case t1 => t1

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

@@ -72,7 +72,6 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
    */
   def methPart(tree: Tree): Tree = stripApply(tree) match {
     case TypeApply(fn, _) => methPart(fn)
-    case AppliedTypeTree(fn, _) => methPart(fn) // !!! should not be needed
     case Block(stats, expr) => methPart(expr)
     case mp => mp
   }
@@ -152,7 +151,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   def isRepeatedParamType(tpt: Tree)(implicit ctx: Context): Boolean = tpt match {
     case ByNameTypeTree(tpt1) => isRepeatedParamType(tpt1)
     case tpt: TypeTree => tpt.typeOpt.isRepeatedParam
-    case AppliedTypeTree(Select(_, tpnme.REPEATED_PARAM_CLASS), _) => true
+    case TypeApply(Select(_, tpnme.REPEATED_PARAM_CLASS), _) => true
     case _ => false
   }
 
@@ -164,7 +163,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case AndTypeTree(tpt1, tpt2) => mayBeTypePat(tpt1) || mayBeTypePat(tpt2)
     case OrTypeTree(tpt1, tpt2) => mayBeTypePat(tpt1) || mayBeTypePat(tpt2)
     case RefinedTypeTree(tpt, refinements) => mayBeTypePat(tpt) || refinements.exists(_.isInstanceOf[Bind])
-    case AppliedTypeTree(tpt, args) => mayBeTypePat(tpt) || args.exists(_.isInstanceOf[Bind])
+    case TypeApply(tpt, args) => mayBeTypePat(tpt) || args.exists(_.isInstanceOf[Bind])
     case Select(tpt, _) => mayBeTypePat(tpt)
     case Annotated(tpt, _) => mayBeTypePat(tpt)
     case _ => false
@@ -578,8 +577,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
           loop(fn, targss, args :: argss)
         case TypeApply(fn, targs) =>
           loop(fn, targs ::: targss, argss)
-        case AppliedTypeTree(fn, targs) =>
-          loop(fn, targs ::: targss, argss)
         case _ =>
           (tree, targss, argss)
       }

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

@@ -634,13 +634,6 @@ object Trees {
     def forwardTo = tpt
   }
 
-  /** tpt[args] */
-  case class AppliedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], args: List[Tree[T]])
-    extends ProxyTree[T] with TypTree[T] {
-    type ThisTree[-T >: Untyped] = AppliedTypeTree[T]
-    def forwardTo = tpt
-  }
-
   /** [typeparams] -> tpt */
   case class LambdaTypeTree[-T >: Untyped] private[ast] (tparams: List[TypeDef[T]], body: Tree[T])
     extends TypTree[T] {
@@ -898,7 +891,6 @@ object Trees {
     type AndTypeTree = Trees.AndTypeTree[T]
     type OrTypeTree = Trees.OrTypeTree[T]
     type RefinedTypeTree = Trees.RefinedTypeTree[T]
-    type AppliedTypeTree = Trees.AppliedTypeTree[T]
     type LambdaTypeTree = Trees.LambdaTypeTree[T]
     type ByNameTypeTree = Trees.ByNameTypeTree[T]
     type TypeBoundsTree = Trees.TypeBoundsTree[T]
@@ -1060,10 +1052,6 @@ object Trees {
         case tree: RefinedTypeTree if (tpt eq tree.tpt) && (refinements eq tree.refinements) => tree
         case _ => finalize(tree, untpd.RefinedTypeTree(tpt, refinements))
       }
-      def AppliedTypeTree(tree: Tree)(tpt: Tree, args: List[Tree]): AppliedTypeTree = tree match {
-        case tree: AppliedTypeTree if (tpt eq tree.tpt) && (args eq tree.args) => tree
-        case _ => finalize(tree, untpd.AppliedTypeTree(tpt, args))
-      }
       def LambdaTypeTree(tree: Tree)(tparams: List[TypeDef], body: Tree): LambdaTypeTree = tree match {
         case tree: LambdaTypeTree if (tparams eq tree.tparams) && (body eq tree.body) => tree
         case _ => finalize(tree, untpd.LambdaTypeTree(tparams, body))
@@ -1217,8 +1205,6 @@ object Trees {
             cpy.OrTypeTree(tree)(transform(left), transform(right))
           case RefinedTypeTree(tpt, refinements) =>
             cpy.RefinedTypeTree(tree)(transform(tpt), transformSub(refinements))
-          case AppliedTypeTree(tpt, args) =>
-            cpy.AppliedTypeTree(tree)(transform(tpt), transform(args))
           case LambdaTypeTree(tparams, body) =>
             implicit val ctx = localCtx
             cpy.LambdaTypeTree(tree)(transformSub(tparams), transform(body))
@@ -1349,8 +1335,6 @@ object Trees {
             this(this(x, left), right)
           case RefinedTypeTree(tpt, refinements) =>
             this(this(x, tpt), refinements)
-          case AppliedTypeTree(tpt, args) =>
-            this(this(x, tpt), args)
           case LambdaTypeTree(tparams, body) =>
             implicit val ctx = localCtx
             this(this(x, tparams), body)

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

@@ -148,9 +148,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def RefinedTypeTree(parent: Tree, refinements: List[Tree], refineCls: ClassSymbol)(implicit ctx: Context): Tree =
     ta.assignType(untpd.RefinedTypeTree(parent, refinements), parent, refinements, refineCls)
 
-  def AppliedTypeTree(tycon: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree =
-    ta.assignType(untpd.AppliedTypeTree(tycon, args), tycon, args)
-
   def ByNameTypeTree(result: Tree)(implicit ctx: Context): ByNameTypeTree =
     ta.assignType(untpd.ByNameTypeTree(result), result)
 

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

@@ -286,7 +286,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def AndTypeTree(left: Tree, right: Tree): AndTypeTree = new AndTypeTree(left, right)
   def OrTypeTree(left: Tree, right: Tree): OrTypeTree = new OrTypeTree(left, right)
   def RefinedTypeTree(tpt: Tree, refinements: List[Tree]): RefinedTypeTree = new RefinedTypeTree(tpt, refinements)
-  def AppliedTypeTree(tpt: Tree, args: List[Tree]): AppliedTypeTree = new AppliedTypeTree(tpt, args)
   def LambdaTypeTree(tparams: List[TypeDef], body: Tree): LambdaTypeTree = new LambdaTypeTree(tparams, body)
   def ByNameTypeTree(result: Tree): ByNameTypeTree = new ByNameTypeTree(result)
   def TypeBoundsTree(lo: Tree, hi: Tree): TypeBoundsTree = new TypeBoundsTree(lo, hi)
@@ -309,9 +308,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
    */
   def New(tpt: Tree, argss: List[List[Tree]])(implicit ctx: Context): Tree = {
     val (tycon, targs) = tpt match {
-      case AppliedTypeTree(tycon, targs) =>
+      case TypeApply(tycon, targs) =>
         (tycon, targs)
-      case TypedSplice(AppliedTypeTree(tycon, targs)) =>
+      case TypedSplice(TypeApply(tycon, targs)) =>
         (TypedSplice(tycon), targs map (TypedSplice(_)))
       case TypedSplice(tpt1: tpd.Tree) =>
         val tycon = tpt1.tpe.typeConstructor
@@ -337,9 +336,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     case _ => Apply(tpt, Nil)
   }
 
-  def AppliedTypeTree(tpt: Tree, arg: Tree): AppliedTypeTree =
-    AppliedTypeTree(tpt, arg :: Nil)
-
   def TypeTree(tpe: Type)(implicit ctx: Context): TypedSplice = TypedSplice(TypeTree().withTypeUnchecked(tpe))
 
   def unitLiteral = Literal(Constant(()))

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

@@ -324,7 +324,6 @@ object StdNames {
     // Compiler utilized names
 
     val AnnotatedType: N        = "AnnotatedType"
-    val AppliedTypeTree: N      = "AppliedTypeTree"
     val ArrayAnnotArg: N        = "ArrayAnnotArg"
     val Constant: N             = "Constant"
     val ConstantType: N         = "ConstantType"

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -373,10 +373,7 @@ class TreePickler(pickler: TastyPickler) {
           }
         case TypeApply(fun, args) =>
           writeByte(if (tree.isType) TYPEAPPLYtpt else TYPEAPPLY)
-          withLength {
-            pickleTree(fun)
-            args.foreach(pickleTpt)
-          }
+          withLength { pickleTree(fun); args.foreach(pickleTpt) }
         case Literal(const1) =>
           pickleConstant {
             tree.tpe match {
@@ -523,9 +520,6 @@ class TreePickler(pickler: TastyPickler) {
             refinements.foreach(preRegister)
             withLength { pickleTree(parent); refinements.foreach(pickleTree) }
           }
-        case AppliedTypeTree(tycon, args) =>
-          writeByte(TYPEAPPLYtpt)
-          withLength { pickleTree(tycon); args.foreach(pickleTree) }
         case AndTypeTree(tp1, tp2) =>
           writeByte(ANDtpt)
           withLength { pickleTree(tp1); pickleTree(tp2) }
@@ -818,9 +812,6 @@ class TreePickler(pickler: TastyPickler) {
       case RefinedTypeTree(parent, refinements) =>
         writeByte(REFINEDtpt)
         withLength { pickleTpt(parent); refinements.foreach(pickleTerm) }
-      case AppliedTypeTree(tycon, args) =>
-        writeByte(TYPEAPPLYtpt)
-        withLength { pickleTpt(tycon); args.foreach(pickleTpt) }
       case AndTypeTree(tp1, tp2) =>
         writeByte(ANDtpt)
         withLength { pickleTpt(tp1); pickleTpt(tp2) }

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1131,7 +1131,7 @@ class TreeUnpickler(reader: TastyReader,
               // types. This came up in #137 of collection strawman.
               val tycon = readTpt()
               val args = until(end)(readTpt())
-              untpd.AppliedTypeTree(tycon, args).withType(tycon.tpe.safeAppliedTo(args.tpes))
+              untpd.TypeApply(tycon, args).withType(tycon.tpe.safeAppliedTo(args.tpes))
             case ANDtpt =>
               val tpt1 = readTpt()
               val tpt2 = readTpt()
@@ -1376,8 +1376,6 @@ class TreeUnpickler(reader: TastyReader,
             untpd.Import(readUntyped(), readSelectors())
           case REFINEDtpt =>
             untpd.RefinedTypeTree(readUntyped(), until(end)(readUntyped()))
-          case TYPEAPPLYtpt =>
-            untpd.AppliedTypeTree(readUntyped(), until(end)(readUntyped()))
           case ANDtpt =>
             untpd.AndTypeTree(readUntyped(), readUntyped())
           case ORtpt =>

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -1210,7 +1210,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       case APPLIEDTYPEtree =>
         val tpt = readTreeRef()
         val args = until(end, () => readTreeRef())
-        AppliedTypeTree(tpt, args)
+        TypeApply(tpt, args)
 
       case TYPEBOUNDStree =>
         val lo = readTreeRef()