Added infix methods for some tree constructions

Added several forms of "select" and "appliedTo" methods which construct Select, Apply, TypeApply
trees.

Motivation: Infix methods allow chaining which is more legible than deep nesting.

12 files changed, 85 insertions, 67 deletions

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index f0151e1d3..d9c57bd23 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -25,17 +25,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Select(qualifier: Tree, name: Name)(implicit ctx: Context): Select =
     ta.assignType(untpd.Select(qualifier, name), qualifier)
 
-  def Select(qualifier: Tree, tp: NamedType)(implicit ctx: Context): Select =
-    untpd.Select(qualifier, tp.name).withType(tp)
-
-  def Select(qualifier: Tree, sym: Symbol)(implicit ctx: Context): Select =
-    untpd.Select(qualifier, sym.name).withType(
-      TermRef.withSig(qualifier.tpe, sym.name.asTermName, sym.signature, sym.denot.asSeenFrom(qualifier.tpe)))
-
-  def SelectWithSig(qualifier: Tree, name: Name, sig: Signature)(implicit ctx: Context) =
-    untpd.SelectWithSig(qualifier, name, sig)
-      .withType(TermRef.withSig(qualifier.tpe, name.asTermName, sig))
-
   def SelectFromTypeTree(qualifier: Tree, name: Name)(implicit ctx: Context): SelectFromTypeTree =
     ta.assignType(untpd.SelectFromTypeTree(qualifier, name), qualifier)
 
@@ -264,7 +253,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def ref(tp: NamedType)(implicit ctx: Context): NameTree =
     if (tp.symbol.isStatic) Ident(tp)
     else tp.prefix match {
-      case pre: TermRef => Select(ref(pre), tp)
+      case pre: TermRef => ref(pre).select(tp)
       case pre => SelectFromTypeTree(TypeTree(pre), tp)
     } // no checks necessary
 
@@ -287,12 +276,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** new C(args), calling given constructor `constr` of C */
   def New(tp: Type, constr: TermSymbol, args: List[Tree])(implicit ctx: Context): Apply = {
     val targs = tp.argTypes
-    Apply(
-      Select(
-        New(tp withoutArgs targs),
-        TermRef.withSig(tp.normalizedPrefix, constr))
-        .appliedToTypes(targs),
-      args)
+    New(tp withoutArgs targs)
+      .select(TermRef.withSig(tp.normalizedPrefix, constr))
+      .appliedToTypes(targs)
+      .appliedToArgs(args)
   }
 
   /** An object def
@@ -384,14 +371,37 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def changeOwner(from: Symbol, to: Symbol)(implicit ctx: Context): ThisTree =
       new TreeTypeMap(ownerMap = (sym => if (sym == from) to else sym)).apply(tree)
 
-    def appliedToArg(arg: Tree)(implicit ctx: Context): Tree = appliedToArgs(arg :: Nil)
+    def select(name: Name)(implicit ctx: Context): Select =
+      Select(tree, name)
+
+    def select(tp: NamedType)(implicit ctx: Context): Select =
+      untpd.Select(tree, tp.name).withType(tp)
+
+    def select(sym: Symbol)(implicit ctx: Context): Select =
+      untpd.Select(tree, sym.name).withType(
+        TermRef.withSig(tree.tpe, sym.name.asTermName, sym.signature, sym.denot.asSeenFrom(tree.tpe)))
 
-    def appliedToArgs(args: List[Tree])(implicit ctx: Context): Tree =
-      if (args.isEmpty) tree else Apply(tree, args)
+    def selectWithSig(name: Name, sig: Signature)(implicit ctx: Context) =
+      untpd.SelectWithSig(tree, name, sig)
+        .withType(TermRef.withSig(tree.tpe, name.asTermName, sig))
+
+    def appliedTo(arg: Tree)(implicit ctx: Context): Tree =
+      appliedToArgs(arg :: Nil)
+
+    def appliedTo(arg: Tree, args: Tree*)(implicit ctx: Context): Tree =
+      appliedToArgs(arg :: args.toList)
+
+    def appliedToArgs(args: List[Tree])(implicit ctx: Context): Apply =
+      Apply(tree, args)
 
     def appliedToArgss(argss: List[List[Tree]])(implicit ctx: Context): Tree =
       ((tree: Tree) /: argss)(Apply(_, _))
 
+    def appliedToNone(implicit ctx: Context): Apply = appliedToArgs(Nil)
+
+    def appliedToType(targ: Type)(implicit ctx: Context): Tree =
+      appliedToTypes(targ :: Nil)
+
     def appliedToTypes(targs: List[Type])(implicit ctx: Context): Tree =
       appliedToTypeTrees(targs map (TypeTree(_)))
 
@@ -444,7 +454,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val mname      = ("to" + numericCls.name).toTermName
     val conversion = tree.tpe member mname
     if (conversion.symbol.exists)
-      ensureApplied(Select(tree, conversion.symbol.termRef))
+      ensureApplied(tree.select(conversion.symbol.termRef))
     else if (tree.tpe.widen isRef numericCls)
       tree
     else {
@@ -464,10 +474,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def runtimeCall(name: TermName, args: List[Tree])(implicit ctx: Context): Tree = ???
 
   def mkAnd(tree1: Tree, tree2: Tree)(implicit ctx: Context) =
-    Apply(Select(tree1, defn.Boolean_and), tree2 :: Nil)
+    tree1.select(defn.Boolean_and).appliedTo(tree2)
 
   def mkAsInstanceOf(tree: Tree, pt: Type)(implicit ctx: Context): Tree =
-    TypeApply(Select(tree, defn.Any_asInstanceOf), TypeTree(pt) :: Nil)
+    tree.select(defn.Any_asInstanceOf).appliedToType(pt)
 
   def ensureConforms(tree: Tree, pt: Type)(implicit ctx: Context): Tree =
     if (tree.tpe <:< pt) tree else mkAsInstanceOf(tree, pt)
diff --git a/src/dotty/tools/dotc/core/pickling/UnPickler.scala b/src/dotty/tools/dotc/core/pickling/UnPickler.scala
index 462c10137..5b41d1382 100644
--- a/src/dotty/tools/dotc/core/pickling/UnPickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/UnPickler.scala
@@ -1080,7 +1080,7 @@ class UnPickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot:
         setSym()
         val qualifier = readTreeRef()
         val selector = readNameRef()
-        Select(qualifier, symbol.namedType)
+        qualifier.select(symbol.namedType)
       case IDENTtree =>
         setSymName()
         Ident(symbol.namedType)
diff --git a/src/dotty/tools/dotc/transform/Constructors.scala b/src/dotty/tools/dotc/transform/Constructors.scala
index bc9d6ea61..4bef41d8f 100644
--- a/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/src/dotty/tools/dotc/transform/Constructors.scala
@@ -17,7 +17,8 @@ class Constructors extends TreeTransform {
       val claz = tree.symbol.enclosingClass.asClass
       val zuper = claz.info.parents.head.typeSymbol
       cpy.DefDef(tree, tree.mods, tree.name, tree.tparams, tree.vparamss, tree.tpt, rhs = {
-        val parentCall = Apply(Select(Super(This(claz), tpnme.EMPTY, true), zuper.primaryConstructor), Nil)
+        val parentCall =
+          Super(This(claz), tpnme.EMPTY, true).select(zuper.primaryConstructor).appliedToNone
         if(tree.rhs.isEmpty) parentCall
         else Block(List(parentCall), tree.rhs)
 
diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala
index c9b92e55f..802e9595b 100644
--- a/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/src/dotty/tools/dotc/transform/Erasure.scala
@@ -98,7 +98,7 @@ object Erasure {
           else {
             assert(cls ne defn.ArrayClass)
             val arg = safelyRemovableUnboxArg(tree)
-            if (arg.isEmpty) Apply(ref(boxMethod(cls.asClass)), tree :: Nil)
+            if (arg.isEmpty) ref(boxMethod(cls.asClass)).appliedTo(tree)
             else {
               ctx.log(s"boxing an unbox: ${tree.symbol} -> ${arg.tpe}")
               arg
@@ -116,14 +116,16 @@ object Erasure {
               // via the unboxed type would yield a NPE (see SI-5866)
               unbox(tree, underlying)
             else
-              Apply(Select(adaptToType(tree, clazz.typeRef), clazz.valueClassUnbox), Nil)
+              adaptToType(tree, clazz.typeRef)
+                .select(clazz.valueClassUnbox)
+                .appliedToNone
           cast(tree1, pt)
         case _ =>
           val cls = pt.classSymbol
           if (cls eq defn.UnitClass) constant(tree, Literal(Constant(())))
           else {
             assert(cls ne defn.ArrayClass)
-            Apply(ref(unboxMethod(cls.asClass)), tree :: Nil)
+            ref(unboxMethod(cls.asClass)).appliedTo(tree)
           }
       }
     }
@@ -267,7 +269,7 @@ object Erasure {
     override def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(implicit ctx: Context) =
       EmptyTree
 
-    override def typedStats(stats: List[untpd.Tree], exprOwner: Symbol)(implicit ctx: Context): List[tpd.Tree] = {
+    override def typedStats(stats: List[untpd.Tree], exprOwner: Symbol)(implicit ctx: Context): List[Tree] = {
       val statsFlatten = Trees.flatten(stats)
       val stats1 = super.typedStats(statsFlatten, exprOwner)
 
@@ -343,7 +345,7 @@ object Erasure {
       bridge.entered // this should be safe, as we're executing in context of next phase
       ctx.debuglog(s"generating bridge from ${newDef.symbol} to $bridge")
 
-      val sel: Tree = tpd.Select(This(newDef.symbol.owner.asClass), newDef.symbol.termRef)
+      val sel: Tree = This(newDef.symbol.owner.asClass).select(newDef.symbol.termRef)
 
       val resultType = bridge.info.widen.resultType
       tpd.DefDef(bridge, { paramss: List[List[tpd.Tree]] =>
diff --git a/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/src/dotty/tools/dotc/transform/ExtensionMethods.scala
index 55b53ef4d..fbdc42a54 100644
--- a/src/dotty/tools/dotc/transform/ExtensionMethods.scala
+++ b/src/dotty/tools/dotc/transform/ExtensionMethods.scala
@@ -158,7 +158,7 @@ class ExtensionMethods extends MacroTransform with IdentityDenotTransformer { th
           // which leaves the actual argument application for extensionCall.
           val forwarder = ref(extensionMeth.termRef)
             .appliedToTypes(origTParams.map(_.typeRef))
-            .appliedToArg(This(origClass))
+            .appliedTo(This(origClass))
             .appliedToArgss(vparamss.nestedMap(vparam => ref(vparam.symbol)))
             .withPos(rhs.pos)
           cpy.DefDef(tree, mods, name, tparams, vparamss, tpt, forwarder)
diff --git a/src/dotty/tools/dotc/transform/InterceptedMethods.scala b/src/dotty/tools/dotc/transform/InterceptedMethods.scala
index f5fed6fda..6dd66ec75 100644
--- a/src/dotty/tools/dotc/transform/InterceptedMethods.scala
+++ b/src/dotty/tools/dotc/transform/InterceptedMethods.scala
@@ -91,9 +91,8 @@ class InterceptedMethods extends TreeTransform {
       def alt2 = defn.ScalaRuntimeModule.info.member(nme.hash_)
         .suchThat(_.info.firstParamTypes.head.typeSymbol == defn.AnyClass)
 
-      if (defn.ScalaNumericValueClasses contains s) {
-        tpd.Apply(Ident(alt1.termRef), List(tree))
-      } else tpd.Apply(Ident(alt2.termRef), List(tree))
+      Ident((if (defn.ScalaNumericValueClasses contains s) alt1 else alt2).termRef)
+        .appliedTo(tree)
     }
   }
 
@@ -111,9 +110,9 @@ class InterceptedMethods extends TreeTransform {
             PoundPoundValue(qual)
           } else if (Any_comparisons contains tree.fun.symbol.asTerm) {
             if (tree.fun.symbol eq defn.Any_==) {
-              Apply(Select(qual, defn.Any_equals), tree.args)
+              qual.select(defn.Any_equals).appliedToArgs(tree.args)
             } else if (tree.fun.symbol eq defn.Any_!=) {
-              Select(Apply(Select(qual, defn.Any_equals), tree.args), defn.Boolean_!)
+              qual.select(defn.Any_equals).appliedToArgs(tree.args).select(defn.Boolean_!)
             } else unknown
           } /* else if (isPrimitiveValueClass(qual.tpe.typeSymbol)) {
             // todo: this is needed to support value classes
@@ -130,7 +129,7 @@ class InterceptedMethods extends TreeTransform {
             //    we get a primitive form of _getClass trying to target a boxed value
             //    so we need replace that method name with Object_getClass to get correct behavior.
             //    See SI-5568.
-            Apply(Select(qual, defn.Any_getClass), Nil)
+            qual.select(defn.Any_getClass).appliedToNone
           } else {
             unknown
           }
diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index ecd94a211..75dc10ce4 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -7,6 +7,7 @@ import Contexts._
 import Symbols._
 import Decorators._
 import NameOps._
+import StdNames.nme
 import dotty.tools.dotc.transform.TreeTransforms.{TransformerInfo, TreeTransformer, TreeTransform}
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.ast.{untpd, tpd}
@@ -125,9 +126,11 @@ class LazyValTranformContext {
 
         val holderSymbol = ctx.newSymbol(x.symbol.owner, holderName, containerFlags, holderImpl.typeRef, coord = x.symbol.coord)
         val holderTree = ValDef(holderSymbol, New(holderImpl.typeRef, List(valueInitter)))
-        val methodBody =
-          if(holderType != "LazyRef") Select(Ident(holderSymbol.termRef), "value".toTermName)
-          else TypeApply(Select(Select(Ident(holderSymbol.termRef), "value".toTermName), defn.Any_asInstanceOf), List(TypeTree(tpe)))
+        val methodBody = {
+          val prefix = ref(holderSymbol).select("value".toTermName)
+          if (holderType != "LazyRef") prefix
+          else prefix.select(defn.Any_asInstanceOf).appliedToType(tpe)
+          }
         val methodTree = DefDef(x.symbol.asTerm, methodBody)
         ctx.debuglog(s"found a lazy val ${x.show},\n rewrote with ${holderTree.show}")
         Thicket(holderTree, methodTree)
@@ -141,7 +144,7 @@ class LazyValTranformContext {
       *     flag = true
       *     target
       *     }
-      *   }
+      *   }`
       */
 
     def mkNonThreadSafeDef(target: Symbol, flag: Symbol, rhs: Tree)(implicit ctx: Context) = {
@@ -162,7 +165,7 @@ class LazyValTranformContext {
       * }
       */
     def mkDefNonThreadSafeNonNullable(target: Symbol, rhs: Tree)(implicit ctx: Context) = {
-      val cond = Apply(Select(Ident(target.termRef), "eq".toTermName), List(Literal(Constant(null))))
+      val cond = Ident(target.termRef).select(nme.eq).appliedTo(Literal(Constant(null)))
       val exp = Ident(target.termRef)
       val setTarget = Assign(exp, rhs)
       val init = Block(List(setTarget), exp)
@@ -236,6 +239,7 @@ class LazyValTranformContext {
       *     }
       *   result
       * }
+      * FIXME: Don't use strings with toTermName, use predefined names instead.
       */
     def mkThreadSafeDef(methodSymbol: TermSymbol, claz: ClassSymbol, ord: Int, target: Symbol, rhs: Tree, tp: Types.Type, offset: Tree, getFlag: Tree, stateMask: Tree, casFlag: Tree, setFlagState: Tree, waitOnLock: Tree)(implicit ctx: Context) = {
       val initState = Literal(Constants.Constant(0))
@@ -262,16 +266,16 @@ class LazyValTranformContext {
         val handler = Closure(handlerSymbol, {
           args =>
             val exception = args.head.head
-            val complete = Apply(setFlagState, List(thiz, offset, initState, Literal(Constant(ord))))
+            val complete = setFlagState.appliedTo(thiz, offset, initState, Literal(Constant(ord)))
             Block(List(complete), Throw(exception))
         })
 
         val compute = Assign(Ident(resultSymbol.termRef), rhs)
         val tr = Try(compute, handler, EmptyTree)
         val assign = Assign(Ident(target.termRef), Ident(resultSymbol.termRef))
-        val complete = Apply(setFlagState, List(thiz, offset, computedState, Literal(Constant(ord))))
+        val complete = setFlagState.appliedTo(thiz, offset, computedState, Literal(Constant(ord)))
         val noRetry = Assign(Ident(retrySymbol.termRef), Literal(Constants.Constant(false)))
-        val body = If(Apply(casFlag, List(thiz, offset, Ident(flagSymbol.termRef), computeState, Literal(Constant(ord)))),
+        val body = If(casFlag.appliedTo(thiz, offset, Ident(flagSymbol.termRef), computeState, Literal(Constant(ord))),
           Block(tr :: assign :: complete :: noRetry :: Nil, Literal(Constant(()))),
           Literal(Constant(())))
 
@@ -279,12 +283,12 @@ class LazyValTranformContext {
       }
 
       val waitFirst = {
-        val wait = Apply(waitOnLock, List(thiz, offset, Ident(flagSymbol.termRef), Literal(Constant(ord))))
+        val wait = waitOnLock.appliedTo(thiz, offset, Ident(flagSymbol.termRef), Literal(Constant(ord)))
         CaseDef(computeState, EmptyTree, wait)
       }
 
       val waitSecond = {
-        val wait = Apply(waitOnLock, List(thiz, offset, Ident(flagSymbol.termRef), Literal(Constant(ord))))
+        val wait = waitOnLock.appliedTo(thiz, offset, Ident(flagSymbol.termRef), Literal(Constant(ord)))
         CaseDef(notifyState, EmptyTree, wait)
       }
 
@@ -295,10 +299,10 @@ class LazyValTranformContext {
         CaseDef(computedState, EmptyTree, body)
       }
 
-      val cases = Match(Apply(stateMask, List(Ident(flagSymbol.termRef), Literal(Constant(ord)))),
+      val cases = Match(stateMask.appliedTo(Ident(flagSymbol.termRef), Literal(Constant(ord))),
         List(compute, waitFirst, waitSecond, computed)) //todo: annotate with @switch
 
-      val whileBody = Block(List(Assign(Ident(flagSymbol.termRef), Apply(getFlag, List(thiz, offset)))), cases)
+      val whileBody = Block(List(Assign(Ident(flagSymbol.termRef), getFlag.appliedTo(thiz, offset))), cases)
       val cycle = untpd.WhileDo(whileCond, whileBody).withTypeUnchecked(defn.UnitType)
       DefDef(methodSymbol, Block(resultDef :: retryDef :: flagDef :: cycle :: Nil, Ident(resultSymbol.termRef)))
     }
@@ -334,7 +338,7 @@ class LazyValTranformContext {
               val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType)
               addSym(claz, flagSymbol)
               flag = ValDef(flagSymbol, Literal(Constants.Constant(0L)))
-              val offsetTree = ValDef(offsetSymbol, Apply(getOffset, List(thiz, Literal(Constant(flagName.toString)))))
+              val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thiz, Literal(Constant(flagName.toString))))
               info.defs = offsetTree :: info.defs
             }
 
@@ -344,7 +348,7 @@ class LazyValTranformContext {
             val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType)
             addSym(claz, flagSymbol)
             flag = ValDef(flagSymbol, Literal(Constants.Constant(0L)))
-            val offsetTree = ValDef(offsetSymbol, Apply(getOffset, List(thiz, Literal(Constant(flagName.toString)))))
+            val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thiz, Literal(Constant(flagName.toString))))
             appendOffsetDefs += (companion.name.moduleClassName -> new OffsetInfo(List(offsetTree), ord))
         }
 
diff --git a/src/dotty/tools/dotc/transform/Nullarify.scala b/src/dotty/tools/dotc/transform/Nullarify.scala
index 664b4bee1..8d967cc1a 100644
--- a/src/dotty/tools/dotc/transform/Nullarify.scala
+++ b/src/dotty/tools/dotc/transform/Nullarify.scala
@@ -85,11 +85,11 @@ class Nullarify extends TreeTransform with InfoTransformer {
     def result(implicit ctx: Context) = {
       tp1.widen match {
         case MethodType(Nil, _) if origType.widenExpr.isInstanceOf[ValueType] =>
-          Apply(tree1, Nil)
+          tree1.appliedToNone
         case _ =>
           origType match {
             case _: ExprType => // it's a by-name parameter
-              Apply(Select(tree1, defn.Function0_apply), Nil)
+              tree1.select(defn.Function0_apply).appliedToNone
             case _ =>
               tree1
           }
diff --git a/src/dotty/tools/dotc/transform/Splitter.scala b/src/dotty/tools/dotc/transform/Splitter.scala
index 978a9cce4..745919f3a 100644
--- a/src/dotty/tools/dotc/transform/Splitter.scala
+++ b/src/dotty/tools/dotc/transform/Splitter.scala
@@ -80,12 +80,12 @@ class Splitter extends TreeTransform {
     else {
       def choose(qual: Tree, syms: List[Symbol]): Tree = {
         def testOrCast(which: Symbol, mbr: Symbol) =
-          TypeApply(Select(qual, which), TypeTree(mbr.owner.typeRef) :: Nil)
+          qual.select(which).appliedToType(mbr.owner.typeRef)
         def select(sym: Symbol) = {
           val qual1 =
             if (qual.tpe derivesFrom sym.owner) qual
             else testOrCast(defn.Any_asInstanceOf, sym)
-          Select(qual1, sym) withPos tree.pos
+          qual1.select(sym).withPos(tree.pos)
         }
         syms match {
           case Nil =>
diff --git a/src/dotty/tools/dotc/transform/SuperAccessors.scala b/src/dotty/tools/dotc/transform/SuperAccessors.scala
index d6af96301..0fbf33869 100644
--- a/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -98,7 +98,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
         acc
       }
 
-      Select(This(clazz), superAcc) withPos sel.pos
+      This(clazz).select(superAcc).withPos(sel.pos)
     }
 
     private def transformArgs(formals: List[Type], args: List[Tree])(implicit ctx: Context) =
@@ -274,7 +274,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
                           sym.copySymDenotation(initFlags = sym.flags | Method, info = ensureMethodic(sym.info))
                             .installAfter(thisTransformer)
                           val superAcc =
-                            Select(Super(This(currentClass), tpnme.EMPTY, inConstrCall = false), alias)
+                            Super(This(currentClass), tpnme.EMPTY, inConstrCall = false).select(alias)
                           DefDef(sym, ensureConforms(superAcc, sym.info.widen))
                         }
                         return forwarder(ctx.withPhase(thisTransformer.next))
@@ -443,16 +443,18 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
             clazz, accName, Artifact, accType, coord = tree.pos).enteredAfter(thisTransformer)
         val code = polyDefDef(newAcc, trefs => vrefss => {
           val (receiver :: _) :: tail = vrefss
-          val base = Select(receiver, sym).appliedToTypes(trefs)
+          val base = receiver.select(sym).appliedToTypes(trefs)
           (base /: vrefss)(Apply(_, _))
         })
         ctx.debuglog("created protected accessor: " + code)
         storeAccessorDefinition(clazz, code)
         newAcc
       }
-      val res =
-        Apply(Select(This(clazz), protectedAccessor).appliedToTypeTrees(targs), qual :: Nil)
-          .withPos(tree.pos)
+      val res = This(clazz)
+        .select(protectedAccessor)
+        .appliedToTypeTrees(targs)
+        .appliedTo(qual)
+        .withPos(tree.pos)
       ctx.debuglog(s"Replaced $tree with $res")
       res
     }
@@ -473,13 +475,13 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
             clazz, accName, Artifact, accType, coord = tree.pos).enteredAfter(thisTransformer)
         val code = DefDef(newAcc, vrefss => {
           val (receiver :: value :: Nil) :: Nil = vrefss
-          Assign(Select(receiver, field), value).withPos(tree.pos)
+          Assign(receiver.select(field), value).withPos(tree.pos)
         })
         ctx.debuglog("created protected setter: " + code)
         storeAccessorDefinition(clazz, code)
         newAcc
       }
-      Select(This(clazz), protectedAccessor).withPos(tree.pos)
+      This(clazz).select(protectedAccessor).withPos(tree.pos)
     }
 
     /** Does `sym` need an accessor when accessed from `currentClass`?
diff --git a/src/dotty/tools/dotc/transform/TailRec.scala b/src/dotty/tools/dotc/transform/TailRec.scala
index cd0643a6e..a2278e72f 100644
--- a/src/dotty/tools/dotc/transform/TailRec.scala
+++ b/src/dotty/tools/dotc/transform/TailRec.scala
@@ -329,7 +329,7 @@ class TailRec extends TreeTransform with DenotTransformer {
                   val newDenot = d.copySymDenotation(initFlags = sym.flags &~ Flags.Local)
                   newDenot.installAfter(TailRec.this)
                 }
-                Select(thiz, sym)
+                thiz.select(sym)
               case _ => tree
             }
           }
diff --git a/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 5f65ee414..b209f7647 100644
--- a/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -34,7 +34,7 @@ class TypeTestsCasts extends TreeTransform {
         def isPrimitive(tp: Type) = tp.classSymbol.isPrimitiveValueClass
 
         def derivedTree(qual1: Tree, sym: Symbol, tp: Type) =
-          cpy.TypeApply(tree, Select(qual1, sym) withPos qual.pos, List(TypeTree(tp)))
+          cpy.TypeApply(tree, qual1.select(sym).withPos(qual.pos), List(TypeTree(tp)))
 
         def qualCls = qual.tpe.classSymbol
 
@@ -49,7 +49,7 @@ class TypeTestsCasts extends TreeTransform {
           else argType.dealias match {
             case _: SingletonType =>
               val cmpOp = if (argType derivesFrom defn.AnyValClass) defn.Any_equals else defn.Object_eq
-              Apply(Select(expr, cmpOp), singleton(argType) :: Nil)
+              expr.select(cmpOp).appliedTo(singleton(argType))
             case AndType(tp1, tp2) =>
               evalOnce(expr) { fun =>
                 val erased1 = transformIsInstanceOf(fun, tp1)