Eliminate polyDefDef calls

Author: odersky

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

@@ -404,7 +404,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 +1285,14 @@ 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
 
   /** 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/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/typer/Deriving.scala

@@ -271,16 +271,19 @@ trait Deriving {
       import tpd._
 
       /** The type class instance definition with symbol `sym` */
-      def typeclassInstance(sym: Symbol)(using Context): List[tpd.Tree] => (List[List[tpd.Tree]] => tpd.Tree) = {
-        (tparamRefs: List[tpd.Tree]) => (paramRefss: List[List[tpd.Tree]]) =>
+      def typeclassInstance(sym: Symbol)(using Context): List[List[tpd.Tree]] => tpd.Tree =
+        (paramRefss: List[List[tpd.Tree]]) =>
+          val (tparamRefs, vparamRefss) = paramRefss match
+            case TypeArgs(args) :: rest  => (args, rest)
+            case _ => (Nil, paramRefss)
           val tparamTypes = tparamRefs.tpes
           val tparams = tparamTypes.map(_.typeSymbol.asType)
-          val params = if (paramRefss.isEmpty) Nil else paramRefss.head.map(_.symbol.asTerm)
+          val vparams = if (vparamRefss.isEmpty) Nil else vparamRefss.head.map(_.symbol.asTerm)
           tparams.foreach(ctx.enter(_))
-          params.foreach(ctx.enter(_))
+          vparams.foreach(ctx.enter(_))
           def instantiated(info: Type): Type = info match {
             case info: PolyType => instantiated(info.instantiate(tparamTypes))
-            case info: MethodType => info.instantiate(params.map(_.termRef))
+            case info: MethodType => info.instantiate(vparams.map(_.termRef))
             case info => info.widenExpr
           }
           def companionRef(tp: Type): TermRef = tp match {
@@ -293,11 +296,11 @@ trait Deriving {
           val module = untpd.ref(companionRef(resultType)).withSpan(sym.span)
           val rhs = untpd.Select(module, nme.derived)
           typed(rhs, resultType)
-      }
+      end typeclassInstance
 
       def syntheticDef(sym: Symbol): Tree = inContext(ctx.fresh.setOwner(sym).setNewScope) {
-        if sym.is(Method) then tpd.polyDefDef(sym.asTerm, typeclassInstance(sym))
-        else tpd.ValDef(sym.asTerm, typeclassInstance(sym)(Nil)(Nil))
+        if sym.is(Method) then tpd.DefDef(sym.asTerm, typeclassInstance(sym))
+        else tpd.ValDef(sym.asTerm, typeclassInstance(sym)(Nil))
       }
 
       synthetics.map(syntheticDef).toList

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

@@ -200,10 +200,9 @@ object Inliner {
       flags = meth.flags &~ (Inline | Macro | Override) | Private,
       coord = mdef.rhs.span.startPos).asTerm
     retainer.deriveTargetNameAnnotation(meth, name => BodyRetainerName(name.asTermName))
-    polyDefDef(retainer, targs => prefss =>
+    DefDef(retainer, prefss =>
       inlineCall(
-        ref(meth).appliedToTypeTrees(targs).appliedToArgss(prefss)
-          .withSpan(mdef.rhs.span.startPos))(
+        ref(meth).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

@@ -988,21 +988,23 @@ class Namer { typer: Typer =>
          *  provided `mbr` is accessible and of the right implicit/non-implicit kind.
          */
         def addForwarder(alias: TermName, mbr: SingleDenotation, span: Span): Unit =
+
           def adaptForwarderParams(acc: List[List[tpd.Tree]], tp: Type, prefss: List[List[tpd.Tree]])
             : List[List[tpd.Tree]] = tp match
-              case mt: MethodType =>
+              case mt: MethodType
+              if mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam =>
                 // Note: in this branch we use the assumptions
                 // that `prefss.head` corresponds to `mt.paramInfos` and
                 // that `prefss.tail` corresponds to `mt.resType`
-                if mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam then
-                  val init :+ vararg = prefss.head
-                  val prefs = init :+ ctx.typeAssigner.seqToRepeated(vararg)
-                  adaptForwarderParams(prefs :: acc, mt.resType, prefss.tail)
-                else
-                  adaptForwarderParams(prefss.head :: acc, mt.resType, prefss.tail)
+                val init :+ vararg = prefss.head
+                val prefs = init :+ ctx.typeAssigner.seqToRepeated(vararg)
+                adaptForwarderParams(prefs :: acc, mt.resType, prefss.tail)
+              case mt: MethodOrPoly =>
+                adaptForwarderParams(prefss.head :: acc, mt.resultType, prefss.tail)
               case _ =>
                 acc.reverse ::: prefss
-          if (whyNoForwarder(mbr) == "") {
+
+          if whyNoForwarder(mbr) == "" then
             val sym = mbr.symbol
             val forwarder =
               if mbr.isType then
@@ -1037,17 +1039,16 @@ class Namer { typer: Typer =>
               else {
                 import tpd._
                 val ref = path.select(sym.asTerm)
-                val ddef = tpd.polyDefDef(forwarder.asTerm, targs => prefss =>
-                  ref.appliedToTypeTrees(targs)
-                     .appliedToArgss(adaptForwarderParams(Nil, sym.info.stripPoly, prefss))
+                val ddef = tpd.DefDef(forwarder.asTerm, prefss =>
+                  ref.appliedToArgss(adaptForwarderParams(Nil, sym.info, prefss))
                 )
                 if forwarder.isInlineMethod then
                   PrepareInlineable.registerInlineInfo(forwarder, ddef.rhs)
                 ddef
               }
 
             buf += forwarderDef.withSpan(span)
-          }
+        end addForwarder
 
         def addForwardersNamed(name: TermName, alias: TermName, span: Span): Unit = {
           val size = buf.size