Make polyDefDef pass type trees instead of types

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

Author: odersky

community-build/community-projects/intent

@@ -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]) =

community-build/community-projects/shapeless

@@ -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))
@@ -353,7 +353,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       for overridden <- fwdMeth.allOverriddenSymbols do
         if overridden.is(Extension) then fwdMeth.setFlag(Extension)
         if !overridden.is(Deferred) then 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-bootstrapped/scala/quoted/runtime/impl/QuotesImpl.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/ast/tpd.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/AccessProxies.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/ElimRepeated.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/FullParameterization.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/HoistSuperArgs.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)
   }