Make polyDefDef pass type trees instead of types

This is a first step towards passing reference trees for all parameters
together.

Author: odersky

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

@@ -230,7 +230,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *  Parameter symbols are taken from the `rawParamss` field of `sym`, or
    *  are freshly generated if `rawParamss` is empty.
    */
-  def polyDefDef(sym: TermSymbol, rhsFn: List[Type] => List[List[Tree]] => Tree)(using Context): DefDef = {
+  def polyDefDef(sym: TermSymbol, rhsFn: List[Tree] => List[List[Tree]] => Tree)(using Context): DefDef = {
 
     val (tparams, existingParamss, mtp) = sym.info match {
       case tp: PolyType =>
@@ -281,7 +281,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       case tp => (Nil, tp.widenExpr)
     }
     val (vparamss, rtp) = valueParamss(mtp, existingParamss)
-    val targs = tparams map (_.typeRef)
+    val targs = tparams.map(tparam => ref(tparam.typeRef))
     val argss = vparamss.nestedMap(vparam => Ident(vparam.termRef))
     sym.setParamss(tparams, vparamss)
     DefDef(sym, tparams, vparamss, rtp, rhsFn(targs)(argss))
@@ -351,7 +351,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def forwarder(fn: TermSymbol, name: TermName) = {
       val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
       if (fwdMeth.allOverriddenSymbols.exists(!_.is(Deferred))) fwdMeth.setFlag(Override)
-      polyDefDef(fwdMeth, tprefs => prefss => ref(fn).appliedToTypes(tprefs).appliedToArgss(prefss))
+      polyDefDef(fwdMeth, tprefs => prefss => ref(fn).appliedToTypeTrees(tprefs).appliedToArgss(prefss))
     }
     val forwarders = fns.lazyZip(methNames).map(forwarder)
     val cdef = ClassDef(cls, DefDef(constr), forwarders)

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

@@ -42,7 +42,7 @@ abstract class AccessProxies {
           case info: PolyType => info.paramNames.length
           case _ => 0
         }
-        val (accessRef, forwardedTypes, forwardedArgss) =
+        val (accessRef, forwardedTpts, forwardedArgss) =
           if (passReceiverAsArg(accessor.name))
             (argss.head.head.select(accessed), tps.takeRight(numTypeParams), argss.tail)
           else
@@ -53,7 +53,7 @@ abstract class AccessProxies {
               forwardedArgss.nonEmpty && forwardedArgss.head.nonEmpty) // defensive conditions
             accessRef.becomes(forwardedArgss.head.head)
           else
-            accessRef.appliedToTypes(forwardedTypes).appliedToArgss(forwardedArgss)
+            accessRef.appliedToTypeTrees(forwardedTpts).appliedToArgss(forwardedArgss)
         rhs.withSpan(accessed.span)
       })
 

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

@@ -228,7 +228,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
         // form `Array[? <: SomeType]`, so we need `.argInfos` to get the `TypeBounds`.
         val elemtp = vararg.tpe.widen.argInfos.head
         ref(sym.termRef)
-          .appliedToTypes(trefs)
+          .appliedToTypeTrees(trefs)
           .appliedToArgss(init)
           .appliedToArgs(last :+ wrapArray(vararg, elemtp))
         })

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

@@ -204,7 +204,7 @@ trait FullParameterization {
 
       new TreeTypeMap(
         typeMap = rewireType(_)
-          .subst(origTParams ++ origVParams, trefs ++ argRefs.map(_.tpe))
+          .subst(origTParams ++ origVParams, (trefs ++ argRefs).tpes)
           .substThisUnlessStatic(origClass, thisRef.tpe),
         treeMap = {
           case tree: This if tree.symbol == origClass => thisRef

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

@@ -130,7 +130,7 @@ class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase
         case _ if arg.existsSubTree(needsHoist) =>
           val superMeth = newSuperArgMethod(arg.tpe)
           val superArgDef = polyDefDef(superMeth, trefs => vrefss => {
-            val paramSyms = trefs.map(_.typeSymbol) ::: vrefss.flatten.map(_.symbol)
+            val paramSyms = trefs.map(_.tpe.typeSymbol) ::: vrefss.flatten.map(_.symbol)
             val tmap = new TreeTypeMap(
               typeMap = new TypeMap {
                 lazy val origToParam = origParams.zip(paramSyms).toMap

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

@@ -78,9 +78,9 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
   final val PrivateOrAccessor: FlagSet = Private | Accessor
   final val PrivateOrAccessorOrDeferred: FlagSet = Private | Accessor | Deferred
 
-  def forwarderRhsFn(target: Symbol): List[Type] => List[List[Tree]] => Tree = {
+  def forwarderRhsFn(target: Symbol): List[Tree] => List[List[Tree]] => Tree = {
     targs => vrefss =>
-      val tapp = superRef(target).appliedToTypes(targs)
+      val tapp = superRef(target).appliedToTypeTrees(targs)
       vrefss match {
         case Nil | List(Nil) =>
           // Overriding is somewhat loose about `()T` vs `=> T`, so just pick

compiler/src/dotty/tools/dotc/transform/sjs/PrepJSExports.scala

@@ -440,7 +440,7 @@ object PrepJSExports {
       proxySym: TermSymbol, span: Span)(using Context): Tree = {
 
     polyDefDef(proxySym, { targs => argss =>
-      This(clsSym).select(trgSym).appliedToTypes(targs).appliedToArgss(argss)
+      This(clsSym).select(trgSym).appliedToTypeTrees(targs).appliedToArgss(argss)
     }).withSpan(span)
   }
 

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

@@ -271,14 +271,15 @@ trait Deriving {
       import tpd._
 
       /** The type class instance definition with symbol `sym` */
-      def typeclassInstance(sym: Symbol)(using Context): List[Type] => (List[List[tpd.Tree]] => tpd.Tree) = {
-        (tparamRefs: List[Type]) => (paramRefss: List[List[tpd.Tree]]) =>
-          val tparams = tparamRefs.map(_.typeSymbol.asType)
+      def typeclassInstance(sym: Symbol)(using Context): List[tpd.Tree] => (List[List[tpd.Tree]] => tpd.Tree) = {
+        (tparamRefs: List[tpd.Tree]) => (paramRefss: List[List[tpd.Tree]]) =>
+          val tparamTypes = tparamRefs.tpes
+          val tparams = tparamTypes.map(_.typeSymbol.asType)
           val params = if (paramRefss.isEmpty) Nil else paramRefss.head.map(_.symbol.asTerm)
           tparams.foreach(ctx.enter(_))
           params.foreach(ctx.enter(_))
           def instantiated(info: Type): Type = info match {
-            case info: PolyType => instantiated(info.instantiate(tparamRefs))
+            case info: PolyType => instantiated(info.instantiate(tparamTypes))
             case info: MethodType => info.instantiate(params.map(_.termRef))
             case info => info.widenExpr
           }

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

@@ -202,7 +202,7 @@ object Inliner {
     retainer.deriveTargetNameAnnotation(meth, name => BodyRetainerName(name.asTermName))
     polyDefDef(retainer, targs => prefss =>
       inlineCall(
-        ref(meth).appliedToTypes(targs).appliedToArgss(prefss)
+        ref(meth).appliedToTypeTrees(targs).appliedToArgss(prefss)
           .withSpan(mdef.rhs.span.startPos))(
         using ctx.withOwner(retainer)))
     .showing(i"retainer for $meth: $result", inlining)

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

@@ -1038,7 +1038,7 @@ class Namer { typer: Typer =>
                 import tpd._
                 val ref = path.select(sym.asTerm)
                 val ddef = tpd.polyDefDef(forwarder.asTerm, targs => prefss =>
-                  ref.appliedToTypes(targs)
+                  ref.appliedToTypeTrees(targs)
                      .appliedToArgss(adaptForwarderParams(Nil, sym.info.stripPoly, prefss))
                 )
                 if forwarder.isInlineMethod then

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

@@ -257,7 +257,8 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object DefDef extends DefDefModule:
       def apply(symbol: Symbol, rhsFn: List[TypeRepr] => List[List[Term]] => Option[Term]): DefDef =
-        withDefaultPos(tpd.polyDefDef(symbol.asTerm, tparams => vparamss => yCheckedOwners(rhsFn(tparams)(vparamss), symbol).getOrElse(tpd.EmptyTree)))
+        withDefaultPos(tpd.polyDefDef(symbol.asTerm,
+          tparams => vparamss => yCheckedOwners(rhsFn(tparams.map(_.tpe))(vparamss), symbol).getOrElse(tpd.EmptyTree)))
       def copy(original: Tree)(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]], tpt: TypeTree, rhs: Option[Term]): DefDef =
         tpd.cpy.DefDef(original)(name.toTermName, typeParams, paramss, tpt, yCheckedOwners(rhs, original.symbol).getOrElse(tpd.EmptyTree))
       def unapply(ddef: DefDef): (String, List[TypeDef], List[List[ValDef]], TypeTree, Option[Term]) =