make tpd.appliedToArgss also work for type arguments

Author: odersky

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -181,7 +181,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
         def rewire(stat: Tree) = thisMap.transform(stat).changeOwner(claszSymbol.primaryConstructor, clInitSymbol)
 
-        val callConstructor = New(claszSymbol.typeRef).select(claszSymbol.primaryConstructor).appliedToArgs(Nil)
+        val callConstructor = New(claszSymbol.typeRef).select(claszSymbol.primaryConstructor).appliedToTermArgs(Nil)
         val assignModuleField = Assign(ref(moduleField), callConstructor)
         val remainingConstrStatsSubst = remainingConstrStats.map(rewire)
         val clinit = clinits match {

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

@@ -894,7 +894,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
      *  will return a term or type tree respectively.
      */
     def unapply(tree: tpd.Tree)(using Context): Option[tpd.Tree] = tree match {
-      case tree: GenericApply[Type] if tree.symbol.isQuote => Some(tree.args.head)
+      case tree: GenericApply if tree.symbol.isQuote => Some(tree.args.head)
       case _ => None
     }
   }

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

@@ -970,6 +970,7 @@ object Trees {
     type Super = Trees.Super[T]
     type Apply = Trees.Apply[T]
     type TypeApply = Trees.TypeApply[T]
+    type GenericApply = Trees.GenericApply[T]
     type Literal = Trees.Literal[T]
     type New = Trees.New[T]
     type Typed = Trees.Typed[T]

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

@@ -42,12 +42,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Super(qual, if (mixName.isEmpty) untpd.EmptyTypeIdent else untpd.Ident(mixName), mixinClass)
 
   def Apply(fn: Tree, args: List[Tree])(using Context): Apply = {
-    assert(fn.isInstanceOf[RefTree] || fn.isInstanceOf[GenericApply[_]] || fn.isInstanceOf[Inlined] || fn.isInstanceOf[tasty.TreePickler.Hole])
+    assert(fn.isInstanceOf[RefTree] || fn.isInstanceOf[GenericApply] || fn.isInstanceOf[Inlined] || fn.isInstanceOf[tasty.TreePickler.Hole])
     ta.assignType(untpd.Apply(fn, args), fn, args)
   }
 
   def TypeApply(fn: Tree, args: List[Tree])(using Context): TypeApply = {
-    assert(fn.isInstanceOf[RefTree] || fn.isInstanceOf[GenericApply[_]])
+    assert(fn.isInstanceOf[RefTree] || fn.isInstanceOf[GenericApply])
     ta.assignType(untpd.TypeApply(fn, args), fn, args)
   }
 
@@ -196,7 +196,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.Alternative(trees), trees)
 
   def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree], proto: Type)(using Context): UnApply = {
-    assert(fun.isInstanceOf[RefTree] || fun.isInstanceOf[GenericApply[_]])
+    assert(fun.isInstanceOf[RefTree] || fun.isInstanceOf[GenericApply])
     ta.assignType(untpd.UnApply(fun, implicits, patterns), proto)
   }
 
@@ -463,10 +463,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     if (!ctx.erasedTypes) {
       assert(!TypeErasure.isGeneric(elemTpe), elemTpe) //needs to be done during typer. See Applications.convertNewGenericArray
-      newArr.appliedToTypeTrees(TypeTree(returnTpe) :: Nil).appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(span)
+      newArr.appliedToTypeTrees(TypeTree(returnTpe) :: Nil).appliedToTermArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(span)
     }
     else  // after erasure
-      newArr.appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(span)
+      newArr.appliedToTermArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(span)
   }
 
   /** The wrapped array method name for an array of type elemtp */
@@ -500,7 +500,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     New(tycon)
       .select(TermRef(tycon, constr))
       .appliedToTypes(targs)
-      .appliedToArgs(args)
+      .appliedToTermArgs(args)
   }
 
   /** An object def
@@ -898,14 +898,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     /** A unary apply node with given argument: `tree(arg)` */
     def appliedTo(arg: Tree)(using Context): Apply =
-      appliedToArgs(arg :: Nil)
+      appliedToTermArgs(arg :: Nil)
 
     /** An apply node with given arguments: `tree(arg, args0, ..., argsN)` */
     def appliedTo(arg: Tree, args: Tree*)(using Context): Apply =
-      appliedToArgs(arg :: args.toList)
+      appliedToTermArgs(arg :: args.toList)
 
     /** An apply node with given argument list `tree(args(0), ..., args(args.length - 1))` */
-    def appliedToArgs(args: List[Tree])(using Context): Apply =
+    def appliedToTermArgs(args: List[Tree])(using Context): Apply =
       Apply(tree, args)
 
     /** An applied node that accepts only varargs as arguments */
@@ -916,10 +916,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
      *  `tree (argss(0)) ... (argss(argss.length -1))`
      */
     def appliedToArgss(argss: List[List[Tree]])(using Context): Tree =
-      argss.foldLeft(tree: Tree)(Apply(_, _))
+      argss.foldLeft(tree: Tree) { (t, args) => args match
+        case arg :: args1 if arg.isType => TypeApply(tree, args)
+        case _ => Apply(t, args)
+      }
 
     /** The current tree applied to (): `tree()` */
-    def appliedToNone(using Context): Apply = appliedToArgs(Nil)
+    def appliedToNone(using Context): Apply = Apply(tree, Nil)
 
     /** The current tree applied to given type argument: `tree[targ]` */
     def appliedToType(targ: Type)(using Context): Tree =
@@ -1224,7 +1227,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     letBindUnless(TreeInfo.Idempotent, tree)(within)
 
   def runtimeCall(name: TermName, args: List[Tree])(using Context): Tree =
-    Ident(defn.ScalaRuntimeModule.requiredMethod(name).termRef).appliedToArgs(args)
+    Ident(defn.ScalaRuntimeModule.requiredMethod(name).termRef).appliedToTermArgs(args)
 
   /** An extractor that pulls out type arguments */
   object MaybePoly {

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

@@ -230,7 +230,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
         ref(sym.termRef)
           .appliedToTypeTrees(trefs)
           .appliedToArgss(init)
-          .appliedToArgs(last :+ wrapArray(vararg, elemtp))
+          .appliedToTermArgs(last :+ wrapArray(vararg, elemtp))
         })
       Thicket(tree, forwarderDef)
     else

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

@@ -233,7 +233,7 @@ trait FullParameterization {
       originalDef.vparamss.foldLeft(fun)((acc, vparams) => {
         val meth = acc.tpe.asInstanceOf[MethodType]
         val paramTypes = meth.instantiateParamInfos(vparams.map(_.tpe))
-        acc.appliedToArgs(
+        acc.appliedToTermArgs(
           vparams.lazyZip(paramTypes).map((vparam, paramType) => {
             assert(vparam.tpe <:< paramType.widen) // type should still conform to widened type
             ref(vparam.symbol).ensureConforms(paramType)

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

@@ -34,7 +34,7 @@ class FunctionXXLForwarders extends MiniPhase with IdentityDenotTransformer {
       var idx = -1
       val argss = receiver.tpe.widenDealias.paramInfoss.map(_.map { param =>
         idx += 1
-        argsApply.appliedToArgs(List(Literal(Constant(idx)))).cast(param)
+        argsApply.appliedToTermArgs(List(Literal(Constant(idx)))).cast(param)
       })
       ref(receiver.symbol).appliedToArgss(argss).cast(defn.ObjectType)
     }

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

@@ -73,7 +73,7 @@ class InterceptedMethods extends MiniPhase {
     }
 
     if tree.fun.symbol == defn.Any_!= then
-      qual.select(defn.Any_==).appliedToArgs(tree.args).select(defn.Boolean_!).withSpan(tree.span)
+      qual.select(defn.Any_==).appliedToTermArgs(tree.args).select(defn.Boolean_!).withSpan(tree.span)
     else
       tree
   }

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

@@ -216,7 +216,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
       case _ =>
         val Apply(sel @ Select(New(_), nme.CONSTRUCTOR), args) = tree
         val (callArgs, initArgs) = if (tree.symbol.owner.is(Trait)) (Nil, args) else (args, Nil)
-        (superRef(tree.symbol, tree.span).appliedToArgs(callArgs), Nil, initArgs)
+        (superRef(tree.symbol, tree.span).appliedToTermArgs(callArgs), Nil, initArgs)
     }
 
     val superCallsAndArgs: Map[Symbol, (Tree, List[Tree], List[Tree])] = (

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

@@ -74,7 +74,6 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
     isCurrent(meth)
   }
 
-
   final val PrivateOrAccessor: FlagSet = Private | Accessor
   final val PrivateOrAccessorOrDeferred: FlagSet = Private | Accessor | Deferred
 

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

@@ -390,7 +390,7 @@ object PatternMatcher {
               case mt: MethodType =>
                 assert(mt.isImplicitMethod)
                 val (args, rest) = implicits.splitAt(mt.paramNames.size)
-                applyImplicits(acc.appliedToArgs(args), rest, mt.resultType)
+                applyImplicits(acc.appliedToTermArgs(args), rest, mt.resultType)
               case _ =>
                 assert(implicits.isEmpty)
                 acc

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

@@ -166,7 +166,7 @@ class PickleQuotes extends MacroTransform {
           val literalValue =
             if lit.const.tag == Constants.NullTag || lit.const.tag == Constants.UnitTag then Nil
             else List(body)
-          val constant = reflect.select(s"${typeName}Constant".toTermName).select(nme.apply).appliedToArgs(literalValue)
+          val constant = reflect.select(s"${typeName}Constant".toTermName).select(nme.apply).appliedToTermArgs(literalValue)
           val literal = reflect.select("Literal".toTermName).select(nme.apply).appliedTo(constant)
           reflect.select("TreeMethods".toTermName).select("asExpr".toTermName).appliedTo(literal).asInstance(exprType)
         }

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

@@ -59,7 +59,7 @@ class SpecializeFunctions extends MiniPhase {
 
     // create a forwarding to the specialized apply
     val args = ddef.vparamss.head.map(vparam => ref(vparam.symbol))
-    val rhs = This(cls).select(specializedApply).appliedToArgs(args)
+    val rhs = This(cls).select(specializedApply).appliedToTermArgs(args)
     val ddef1 = cpy.DefDef(ddef)(rhs = rhs)
     Thicket(ddef1, specializedDecl)
   }
@@ -92,7 +92,7 @@ class SpecializeFunctions extends MiniPhase {
             }
         }
 
-        newSel.appliedToArgs(args)
+        newSel.appliedToTermArgs(args)
 
       case _ => tree
     }

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

@@ -117,7 +117,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         coord = clazz.coord).enteredAfter(thisPhase).asTerm
 
       def forwardToRuntime(vrefs: List[Tree]): Tree =
-        ref(defn.runtimeMethodRef("_" + sym.name.toString)).appliedToArgs(This(clazz) :: vrefs)
+        ref(defn.runtimeMethodRef("_" + sym.name.toString)).appliedToTermArgs(This(clazz) :: vrefs)
 
       def ownName: Tree =
         Literal(Constant(clazz.name.stripModuleClassSuffix.toString))

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

@@ -49,7 +49,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
         else {
           // val it = Iterator.single(head) ++ tail.asInstanceOf[Product].productIterator
           // TupleN+1(it.next(), ..., it.next())
-          val fullIterator = ref(defn.RuntimeTuple_consIterator).appliedToArgs(head :: tail :: Nil)
+          val fullIterator = ref(defn.RuntimeTuple_consIterator).appliedToTermArgs(head :: tail :: Nil)
           evalOnce(fullIterator) { it =>
             knownTupleFromIterator(tpes.length, it).asInstance(tree.tpe)
           }
@@ -127,7 +127,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
         else {
           // val it = self.asInstanceOf[Product].productIterator ++ that.asInstanceOf[Product].productIterator
           // TupleN+M(it.next(), ..., it.next())
-          val fullIterator = ref(defn.RuntimeTuple_concatIterator).appliedToArgs(tree.args)
+          val fullIterator = ref(defn.RuntimeTuple_concatIterator).appliedToTermArgs(tree.args)
           evalOnce(fullIterator) { it =>
             knownTupleFromIterator(n + m, it).asInstance(tree.tpe)
           }
@@ -192,7 +192,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
     val size = elements.size
     assert(0 < size && size <= MaxTupleArity)
     val tupleModule = defn.TupleType(size).classSymbol.companionModule
-    ref(tupleModule).select(nme.apply).appliedToTypes(tpes).appliedToArgs(elements)
+    ref(tupleModule).select(nme.apply).appliedToTypes(tpes).appliedToTermArgs(elements)
   }
 
   private def knownTupleFromIterator(size: Int, it: Tree)(using Context): Tree =

compiler/src/dotty/tools/dotc/transform/localopt/StringInterpolatorOpt.scala

@@ -152,13 +152,13 @@ class StringInterpolatorOpt extends MiniPhase {
           val stringToString = defn.StringContextModule_processEscapes.info.asInstanceOf[MethodType]
 
           val process = tpd.Lambda(stringToString, args =>
-            if (isRaw) args.head else ref(defn.StringContextModule_processEscapes).appliedToArgs(args))
+            if (isRaw) args.head else ref(defn.StringContextModule_processEscapes).appliedToTermArgs(args))
 
           evalOnce(pre) { sc =>
             val parts = sc.select(defn.StringContext_parts)
 
             ref(defn.StringContextModule_standardInterpolator)
-              .appliedToArgs(List(process, args, parts))
+              .appliedToTermArgs(List(process, args, parts))
           }
       }
     else

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

@@ -434,7 +434,7 @@ trait Applications extends Compatibility {
     /** Splice new method reference into existing application */
     def spliceMeth(meth: Tree, app: Tree): Tree = app match {
       case Apply(fn, args) =>
-        spliceMeth(meth, fn).appliedToArgs(args)
+        spliceMeth(meth, fn).appliedToTermArgs(args)
       case TypeApply(fn, targs) =>
         // Note: It is important that the type arguments `targs` are passed in new trees
         // instead of being spliced in literally. Otherwise, a type argument to a default
@@ -1095,7 +1095,7 @@ trait Applications extends Compatibility {
       def newGenericArrayCall =
         ref(defn.DottyArraysModule)
           .select(defn.newGenericArrayMethod).withSpan(tree.span)
-          .appliedToTypeTrees(targs).appliedToArgs(args)
+          .appliedToTypeTrees(targs).appliedToTermArgs(args)
 
       if (TypeErasure.isGeneric(targ.tpe))
         newGenericArrayCall

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -381,7 +381,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
             }
             val closureTpe = Types.MethodType(mtpe.paramNames, mtpe.paramInfos, closureResType)
             val closureMethod = dotc.core.Symbols.newSymbol(owner, nme.ANON_FUN, Synthetic | Method, closureTpe)
-            tpd.Closure(closureMethod, tss => new tpd.TreeOps(self).appliedToArgs(tss.head).etaExpand(closureMethod))
+            tpd.Closure(closureMethod, tss => new tpd.TreeOps(self).appliedToTermArgs(tss.head).etaExpand(closureMethod))
           case _ => self
         }