Eliminate polyDefDef def and calls

Author: odersky

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

@@ -224,6 +224,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def DefDef(sym: TermSymbol, rhs: Tree = EmptyTree)(using Context): DefDef =
     ta.assignType(DefDef(sym, Function.const(rhs) _), sym)
 
+  /** A DefDef with given method symbol `sym`.
+   *  @rhsFn  A function from parameter references
+   *          to the method's right-hand side.
+   *  Parameter symbols are taken from the `rawParamss` field of `sym`, or
+   *  are freshly generated if `rawParamss` is empty.
+   */
   def DefDef(sym: TermSymbol, rhsFn: List[List[Tree]] => Tree)(using Context): DefDef =
 
     // Map method type `tp` with remaining parameters stored in rawParamss to
@@ -277,69 +283,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     DefDef(sym, paramss, rtp, rhsFn(paramss.nestedMap(ref)))
   end DefDef
 
-  /** A DefDef with given method symbol `sym`.
-   *  @rhsFn  A function from type parameter types and term parameter references
-   *          to the method's right-hand side.
-   *  Parameter symbols are taken from the `rawParamss` field of `sym`, or
-   *  are freshly generated if `rawParamss` is empty.
-   */
-  def polyDefDef(sym: TermSymbol, rhsFn: List[Tree] => List[List[Tree]] => Tree)(using Context): DefDef = {
-
-    val (tparams, existingParamss, mtp) = sym.info match {
-      case tp: PolyType =>
-        val (tparams, existingParamss) = sym.rawParamss match
-          case tparams :: vparamss =>
-            assert(tparams.hasSameLengthAs(tp.paramNames) && tparams.head.isType)
-            (tparams.asInstanceOf[List[TypeSymbol]], vparamss)
-          case _ =>
-            (newTypeParams(sym, tp.paramNames, EmptyFlags, tp.instantiateParamInfos(_)), Nil)
-        (tparams, existingParamss, tp.instantiate(tparams map (_.typeRef)))
-      case tp => (Nil, sym.rawParamss, tp)
-    }
-
-    def valueParamss(tp: Type, existingParamss: List[List[Symbol]]): (List[List[TermSymbol]], Type) = tp match {
-      case tp: MethodType =>
-        val isParamDependent = tp.isParamDependent
-        val previousParamRefs = if (isParamDependent) mutable.ListBuffer[TermRef]() else null
-
-        def valueParam(name: TermName, origInfo: Type): TermSymbol = {
-          val maybeImplicit =
-            if (tp.isContextualMethod) Given
-            else if (tp.isImplicitMethod) Implicit
-            else EmptyFlags
-          val maybeErased = if (tp.isErasedMethod) Erased else EmptyFlags
-
-          def makeSym(info: Type) = newSymbol(sym, name, TermParam | maybeImplicit | maybeErased, info, coord = sym.coord)
-
-          if (isParamDependent) {
-            val sym = makeSym(origInfo.substParams(tp, previousParamRefs.toList))
-            previousParamRefs += sym.termRef
-            sym
-          }
-          else
-            makeSym(origInfo)
-        }
-
-        val (params, existingParamss1) =
-          if tp.paramInfos.isEmpty then (Nil, existingParamss)
-          else existingParamss match
-            case vparams :: existingParamss1 =>
-              assert(vparams.hasSameLengthAs(tp.paramNames) && vparams.head.isTerm)
-              (vparams.asInstanceOf[List[TermSymbol]], existingParamss1)
-            case _ =>
-              (tp.paramNames.lazyZip(tp.paramInfos).map(valueParam), Nil)
-        val (paramss, rtp) =
-          valueParamss(tp.instantiate(params map (_.termRef)), existingParamss1)
-        (params :: paramss, rtp)
-      case tp => (Nil, tp.widenExpr)
-    }
-    val (vparamss, rtp) = valueParamss(mtp, existingParamss)
-    val targs = tparams.map(tparam => ref(tparam.typeRef))
-    val argss = vparamss.nestedMap(vparam => Ident(vparam.termRef))
-    sym.setParamss(tparams :: vparamss)
-    DefDef(sym, joinSymbols(tparams, vparamss), rtp, rhsFn(targs)(argss))
-  }
-
   def TypeDef(sym: TypeSymbol)(using Context): TypeDef =
     ta.assignType(untpd.TypeDef(sym.name, TypeTree(sym.info)), sym)
 
@@ -404,7 +347,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).appliedToTypeTrees(tprefs).appliedToArgss(prefss))
+      DefDef(fwdMeth, ref(fn).appliedToArgss(_))
     }
     val forwarders = fns.lazyZip(methNames).map(forwarder)
     val cdef = ClassDef(cls, DefDef(constr), forwarders)
@@ -1285,12 +1228,21 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Ident(defn.ScalaRuntimeModule.requiredMethod(name).termRef).appliedToTermArgs(args)
 
   /** An extractor that pulls out type arguments */
-  object MaybePoly {
-    def unapply(tree: Tree): Option[(Tree, List[Tree])] = tree match {
+  object MaybePoly:
+    def unapply(tree: Tree): Option[(Tree, List[Tree])] = tree match
       case TypeApply(tree, targs) => Some(tree, targs)
       case _ => Some(tree, Nil)
-    }
-  }
+
+  object TypeArgs:
+    def unapply(ts: List[Tree]): Option[List[Tree]] =
+      if ts.nonEmpty && ts.head.isType then Some(ts) else None
+
+  /** Split argument clauses into a leading type argument clause if it exists and
+   *  remaining clauses
+   */
+  def splitArgs(argss: List[List[Tree]]): (List[Tree], List[List[Tree]]) = argss match
+    case TypeArgs(targs) :: argss1 => (targs, argss1)
+    case _ => (Nil, argss)
 
   /** A key to be used in a context property that tracks enclosing inlined calls */
   private val InlinedCalls = Property.Key[List[Tree]]()

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -861,9 +861,6 @@ object Symbols {
       case (x: Symbol) :: _ if x.isType => Some(xs.asInstanceOf[List[TypeSymbol]])
       case _ => None
 
-  def joinSymbols(xs: List[Symbol], ys: List[List[Symbol]]): List[List[Symbol]] =
-    if xs.isEmpty then ys else xs :: ys
-
 // ----- Locating predefined symbols ----------------------------------------
 
   def requiredPackage(path: PreName)(using Context): TermSymbol = {

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

@@ -37,17 +37,18 @@ abstract class AccessProxies {
    */
   private def accessorDefs(cls: Symbol)(using Context): Iterator[DefDef] =
     for (accessor <- cls.info.decls.iterator; accessed <- accessedBy.remove(accessor).toOption) yield
-      polyDefDef(accessor.asTerm, tps => argss => {
+      DefDef(accessor.asTerm, prefss => {
         def numTypeParams = accessed.info match {
           case info: PolyType => info.paramNames.length
           case _ => 0
         }
+        val (targs, argss) = splitArgs(prefss)
         val (accessRef, forwardedTpts, forwardedArgss) =
           if (passReceiverAsArg(accessor.name))
-            (argss.head.head.select(accessed), tps.takeRight(numTypeParams), argss.tail)
+            (argss.head.head.select(accessed), targs.takeRight(numTypeParams), argss.tail)
           else
             (if (accessed.isStatic) ref(accessed) else ref(TermRef(cls.thisType, accessed)),
-             tps, argss)
+             targs, argss)
         val rhs =
           if (accessor.name.isSetterName &&
               forwardedArgss.nonEmpty && forwardedArgss.head.nonEmpty) // defensive conditions

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

@@ -222,13 +222,12 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
         .get
         .symbol.asTerm
       // Generate the method
-      val forwarderDef = polyDefDef(forwarderSym, trefs => vrefss => {
-        val init :+ (last :+ vararg) = vrefss
+      val forwarderDef = DefDef(forwarderSym, prefss => {
+        val init :+ (last :+ vararg) = prefss
         // Can't call `.argTypes` here because the underlying array type is of the
         // form `Array[? <: SomeType]`, so we need `.argInfos` to get the `TypeBounds`.
         val elemtp = vararg.tpe.widen.argInfos.head
         ref(sym.termRef)
-          .appliedToTypeTrees(trefs)
           .appliedToArgss(init)
           .appliedToTermArgs(last :+ wrapArray(vararg, elemtp))
         })

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

@@ -117,17 +117,14 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformTemplate(impl: Template)(using Context): Tree =
     cpy.Template(impl)(self = EmptyValDef)
 
-  override def transformDefDef(ddef: DefDef)(using Context): Tree = {
+  override def transformDefDef(ddef: DefDef)(using Context): Tree =
     val meth = ddef.symbol.asTerm
-    if (meth.hasAnnotation(defn.NativeAnnot)) {
+    if meth.hasAnnotation(defn.NativeAnnot) then
       meth.resetFlag(Deferred)
-      polyDefDef(meth,
-        _ => _ => ref(defn.Sys_error.termRef).withSpan(ddef.span)
+      DefDef(meth, _ =>
+        ref(defn.Sys_error.termRef).withSpan(ddef.span)
           .appliedTo(Literal(Constant(s"native method stub"))))
-    }
-
     else ddef
-  }
 
   override def transformStats(trees: List[Tree])(using Context): List[Tree] =
     ast.Trees.flatten(atPhase(thisPhase.next)(reorderAndComplete(trees)))

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

@@ -148,7 +148,8 @@ trait FullParameterization {
    *  of class that contained original defDef
    */
   def fullyParameterizedDef(derived: TermSymbol, originalDef: DefDef, abstractOverClass: Boolean = true)(using Context): Tree =
-    polyDefDef(derived, trefs => vrefss => {
+    DefDef(derived, prefss => {
+      val (trefs, vrefss) = splitArgs(prefss)
       val origMeth = originalDef.symbol
       val origClass = origMeth.enclosingClass.asClass
       val origLeadingTypeParamSyms = allInstanceTypeParams(originalDef, abstractOverClass)

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

@@ -129,8 +129,9 @@ class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase
           cpy.Apply(arg)(fn, hoistSuperArg(arg1, cdef) :: Nil)
         case _ if arg.existsSubTree(needsHoist) =>
           val superMeth = newSuperArgMethod(arg.tpe)
-          val superArgDef = polyDefDef(superMeth, trefs => vrefss => {
-            val paramSyms = trefs.map(_.tpe.typeSymbol) ::: vrefss.flatten.map(_.symbol)
+          val superArgDef = DefDef(superMeth, prefss => {
+            val paramSyms = prefss.flatten.map(pref =>
+              if pref.isType then pref.tpe.typeSymbol else pref.symbol)
             val tmap = new TreeTypeMap(
               typeMap = new TypeMap {
                 lazy val origToParam = origParams.zip(paramSyms).toMap

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

@@ -285,7 +285,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
       for (meth <- mixin.info.decls.toList if needsMixinForwarder(meth))
       yield {
         util.Stats.record("mixin forwarders")
-        transformFollowing(polyDefDef(mkForwarderSym(meth.asTerm, Bridge), forwarderRhsFn(meth)))
+        transformFollowing(DefDef(mkForwarderSym(meth.asTerm, Bridge), forwarderRhsFn(meth)))
       }
 
     cpy.Template(impl)(

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

@@ -77,18 +77,17 @@ 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[Tree] => List[List[Tree]] => Tree = {
-    targs => vrefss =>
+  def forwarderRhsFn(target: Symbol): List[List[Tree]] => Tree =
+    prefss =>
+      val (targs, vargss) = splitArgs(prefss)
       val tapp = superRef(target).appliedToTypeTrees(targs)
-      vrefss match {
+      vargss match
         case Nil | List(Nil) =>
           // Overriding is somewhat loose about `()T` vs `=> T`, so just pick
           // whichever makes sense for `target`
           tapp.ensureApplied
         case _ =>
-          tapp.appliedToArgss(vrefss)
-      }
-  }
+          tapp.appliedToArgss(vargss)
 
   private def competingMethodsIterator(meth: Symbol): Iterator[Symbol] =
     cls.baseClasses.iterator

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

@@ -49,7 +49,7 @@ class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =
       for (superAcc <- mixin.info.decls.filter(_.isSuperAccessor))
         yield {
           util.Stats.record("super accessors")
-          polyDefDef(mkForwarderSym(superAcc.asTerm), forwarderRhsFn(rebindSuper(cls, superAcc)))
+          DefDef(mkForwarderSym(superAcc.asTerm), forwarderRhsFn(rebindSuper(cls, superAcc)))
       }
 
     val overrides = mixins.flatMap(superAccessors)
@@ -64,7 +64,7 @@ class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =
       val cls = meth.owner.asClass
       val ops = new MixinOps(cls, thisPhase)
       import ops._
-      polyDefDef(meth, forwarderRhsFn(rebindSuper(cls, meth)))
+      DefDef(meth, forwarderRhsFn(rebindSuper(cls, meth)))
     }
     else ddef
   }