make tpd.appliedToArgss also work for type arguments

Author: odersky

compiler/src-bootstrapped/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
         }
 

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)
   }
 
@@ -465,10 +465,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 */
@@ -502,7 +502,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     New(tycon)
       .select(TermRef(tycon, constr))
       .appliedToTypes(targs)
-      .appliedToArgs(args)
+      .appliedToTermArgs(args)
   }
 
   /** An object def
@@ -900,14 +900,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 */
@@ -918,10 +918,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 =
@@ -1226,7 +1229,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])] = (