Fix fragile transformation of fromProduct when using @unroll

UnrollDefinitions assumed that the body of `fromProduct` had a specific shape
which is no longer the case with the dependent case class support introduced in
the previous commit. This caused compiler crashes for
tests/run/unroll-multiple.scala and tests/run/unroll-caseclass-integration

This commit fixes this by directly generating the correct fromProduct in
SyntheticMembers. This should also prevent crashes in situations where code is
injected into existing trees like the code coverage support or external compiler
plugins.

Author: smarter

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

@@ -618,6 +618,7 @@ class Definitions {
     @tu lazy val Int_== : Symbol = IntClass.requiredMethod(nme.EQ, List(IntType))
     @tu lazy val Int_>= : Symbol = IntClass.requiredMethod(nme.GE, List(IntType))
     @tu lazy val Int_<= : Symbol = IntClass.requiredMethod(nme.LE, List(IntType))
+    @tu lazy val Int_>  : Symbol = IntClass.requiredMethod(nme.GT, List(IntType))
   @tu lazy val LongType: TypeRef = valueTypeRef("scala.Long", java.lang.Long.TYPE, LongEnc, nme.specializedTypeNames.Long)
   def LongClass(using Context): ClassSymbol = LongType.symbol.asClass
     @tu lazy val Long_+ : Symbol = LongClass.requiredMethod(nme.PLUS, List(LongType))

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

@@ -425,6 +425,7 @@ object StdNames {
     val array_length : N        = "array_length"
     val array_update : N        = "array_update"
     val arraycopy: N            = "arraycopy"
+    val arity: N                = "arity"
     val as: N                   = "as"
     val asTerm: N               = "asTerm"
     val asModule: N             = "asModule"

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

@@ -523,21 +523,47 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
    *  ```
    *  type MirroredMonoType = C[?]
    *  ```
+   *
+   *  However, if the last parameter is annotated `@unroll` then we generate:
+   *
+   *  def fromProduct(x$0: Product): MirroredMonoType =
+   *    val arity = x$0.productArity
+   *    val a$1 = x$0.productElement(0).asInstanceOf[U]
+   *    val b$1 = x$0.productElement(1).asInstanceOf[a$1.Elem]
+   *    val c$1 = (
+   *      if arity > 2 then
+   *        x$0.productElement(2)
+   *      else
+   *        <default getter for the third parameter of C>
+   *    ).asInstanceOf[Seq[String]]
+   *    new C[U](a$1, b$1, c$1*)
    */
   def fromProductBody(caseClass: Symbol, productParam: Tree, optInfo: Option[MirrorImpl.OfProduct])(using Context): Tree =
     val classRef = optInfo match
       case Some(info) => TypeRef(info.pre, caseClass)
       case _ => caseClass.typeRef
-    val (newPrefix, constrMeth) =
+    val (newPrefix, constrMeth, constrSyms) =
       val constr = TermRef(classRef, caseClass.primaryConstructor)
+      val symss = caseClass.primaryConstructor.paramSymss
       (constr.info: @unchecked) match
         case tl: PolyType =>
           val tvars = constrained(tl)
           val targs = for tvar <- tvars yield
             tvar.instantiate(fromBelow = false)
-          (AppliedType(classRef, targs), tl.instantiate(targs).asInstanceOf[MethodType])
+          (AppliedType(classRef, targs), tl.instantiate(targs).asInstanceOf[MethodType], symss(1))
         case mt: MethodType =>
-          (classRef, mt)
+          (classRef, mt, symss.head)
+
+    // Index of the first parameter marked `@unroll` or -1
+    val unrolledFrom =
+      constrSyms.indexWhere(_.hasAnnotation(defn.UnrollAnnot))
+
+    // `val arity = x$0.productArity`
+    val arityDef: Option[ValDef] =
+      if unrolledFrom != -1 then
+        Some(SyntheticValDef(nme.arity, productParam.select(defn.Product_productArity).withSpan(ctx.owner.span.focus)))
+      else None
+    val arityRefTree = arityDef.map(vd => ref(vd.symbol))
 
     // Create symbols for the vals corresponding to each parameter
     // If there are dependent parameters, the infos won't be correct yet.
@@ -550,16 +576,29 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       bindingSyms.foreach: bindingSym =>
         bindingSym.info = bindingSym.info.substParams(constrMeth, bindingRefs)
 
+    def defaultGetterAtIndex(idx: Int): Tree =
+      val defaultGetterPrefix = caseClass.primaryConstructor.name.toTermName
+      ref(caseClass.companionModule).select(NameKinds.DefaultGetterName(defaultGetterPrefix, idx))
+
     val bindingDefs = bindingSyms.zipWithIndex.map: (bindingSym, idx) =>
-      ValDef(bindingSym,
-        productParam.select(defn.Product_productElement).appliedTo(Literal(Constant(idx)))
-          .ensureConforms(bindingSym.info))
+      val selection = productParam.select(defn.Product_productElement).appliedTo(Literal(Constant(idx)))
+      val rhs = (
+        if unrolledFrom != -1 && idx >= unrolledFrom then
+          If(arityRefTree.get.select(defn.Int_>).appliedTo(Literal(Constant(idx))),
+            thenp =
+              selection,
+            elsep =
+              defaultGetterAtIndex(idx))
+        else
+          selection
+      ).ensureConforms(bindingSym.info)
+      ValDef(bindingSym, rhs)
 
     val newArgs = bindingRefs.lazyZip(constrMeth.paramInfos).map: (bindingRef, paramInfo) =>
       val refTree = ref(bindingRef)
       if paramInfo.isRepeatedParam then ctx.typer.seqToRepeated(refTree) else refTree
     Block(
-      bindingDefs,
+      arityDef.toList ::: bindingDefs,
       New(newPrefix, newArgs)
     )
   end fromProductBody

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

@@ -228,46 +228,9 @@ class UnrollDefinitions extends MacroTransform, IdentityDenotTransformer {
     forwarderDef
   }
 
-  private def generateFromProduct(startParamIndices: List[Int], paramCount: Int, defdef: DefDef)(using Context) = {
-    cpy.DefDef(defdef)(
-      name = defdef.name,
-      paramss = defdef.paramss,
-      tpt = defdef.tpt,
-      rhs = Match(
-        ref(defdef.paramss.head.head.asInstanceOf[ValDef].symbol).select(termName("productArity")),
-        startParamIndices.map { paramIndex =>
-          val Apply(select, args) = defdef.rhs: @unchecked
-          CaseDef(
-            Literal(Constant(paramIndex)),
-            EmptyTree,
-            Apply(
-              select,
-              args.take(paramIndex) ++
-                Range(paramIndex, paramCount).map(n =>
-                  ref(defdef.symbol.owner.companionModule)
-                    .select(DefaultGetterName(defdef.symbol.owner.primaryConstructor.name.toTermName, n))
-                )
-            )
-          )
-        } :+ CaseDef(
-          Underscore(defn.IntType),
-          EmptyTree,
-          defdef.rhs
-        )
-      )
-    ).setDefTree
-  }
-
-  private enum Gen:
-    case Substitute(origin: Symbol, newDef: DefDef)
-    case Forwarders(origin: Symbol, forwarders: List[DefDef])
+  case class Forwarders(origin: Symbol, forwarders: List[DefDef])
 
-    def origin: Symbol
-    def extras: List[DefDef] = this match
-      case Substitute(_, d) => d :: Nil
-      case Forwarders(_, ds) => ds
-
-  private def generateSyntheticDefs(tree: Tree, compute: ComputeIndices)(using Context): Option[Gen] = tree match {
+  private def generateSyntheticDefs(tree: Tree, compute: ComputeIndices)(using Context): Option[Forwarders] = tree match {
     case defdef: DefDef if defdef.paramss.nonEmpty =>
       import dotty.tools.dotc.core.NameOps.isConstructorName
 
@@ -277,38 +240,29 @@ class UnrollDefinitions extends MacroTransform, IdentityDenotTransformer {
       val isCaseApply =
         defdef.name == nme.apply && defdef.symbol.owner.companionClass.is(CaseClass)
 
-      val isCaseFromProduct = defdef.name == nme.fromProduct && defdef.symbol.owner.companionClass.is(CaseClass)
-
       val annotated =
         if (isCaseCopy) defdef.symbol.owner.primaryConstructor
         else if (isCaseApply) defdef.symbol.owner.companionClass.primaryConstructor
-        else if (isCaseFromProduct) defdef.symbol.owner.companionClass.primaryConstructor
         else defdef.symbol
 
       compute(annotated) match {
         case Nil => None
         case (paramClauseIndex, annotationIndices) :: Nil =>
           val paramCount = annotated.paramSymss(paramClauseIndex).size
-          if isCaseFromProduct then
-            Some(Gen.Substitute(
-              origin = defdef.symbol,
-              newDef = generateFromProduct(annotationIndices, paramCount, defdef)
-            ))
-          else
-            val generatedDefs =
-              val indices = (annotationIndices :+ paramCount).sliding(2).toList.reverse
-              indices.foldLeft(List.empty[DefDef]):
-                case (defdefs, paramIndex :: nextParamIndex :: Nil) =>
-                  generateSingleForwarder(
-                    defdef,
-                    paramIndex,
-                    paramCount,
-                    nextParamIndex,
-                    paramClauseIndex,
-                    isCaseApply
-                  ) :: defdefs
-                case _ => unreachable("sliding with at least 2 elements")
-            Some(Gen.Forwarders(origin = defdef.symbol, forwarders = generatedDefs))
+          val generatedDefs =
+            val indices = (annotationIndices :+ paramCount).sliding(2).toList.reverse
+            indices.foldLeft(List.empty[DefDef]):
+              case (defdefs, paramIndex :: nextParamIndex :: Nil) =>
+                generateSingleForwarder(
+                  defdef,
+                  paramIndex,
+                  paramCount,
+                  nextParamIndex,
+                  paramClauseIndex,
+                  isCaseApply
+                ) :: defdefs
+              case _ => unreachable("sliding with at least 2 elements")
+          Some(Forwarders(origin = defdef.symbol, forwarders = generatedDefs))
 
         case multiple =>
           report.error("Cannot have multiple parameter lists containing `@unroll` annotation", defdef.srcPos)
@@ -323,14 +277,12 @@ class UnrollDefinitions extends MacroTransform, IdentityDenotTransformer {
     val generatedBody = tmpl.body.flatMap(generateSyntheticDefs(_, compute))
     val generatedConstr0 = generateSyntheticDefs(tmpl.constr, compute)
     val allGenerated = generatedBody ++ generatedConstr0
-    val bodySubs = generatedBody.collect({ case s: Gen.Substitute => s.origin }).toSet
-    val otherDecls = tmpl.body.filterNot(d => d.symbol.exists && bodySubs(d.symbol))
 
     if allGenerated.nonEmpty then
-      val byName = (tmpl.constr :: otherDecls).groupMap(_.symbol.name.toString)(_.symbol)
+      val byName = (tmpl.constr :: tmpl.body).groupMap(_.symbol.name.toString)(_.symbol)
       for
         syntheticDefs <- allGenerated
-        dcl <- syntheticDefs.extras
+        dcl <- syntheticDefs.forwarders
       do
         val replaced = dcl.symbol
         byName.get(dcl.name.toString).foreach { syms =>
@@ -348,7 +300,7 @@ class UnrollDefinitions extends MacroTransform, IdentityDenotTransformer {
       tmpl.parents,
       tmpl.derived,
       tmpl.self,
-      otherDecls ++ allGenerated.flatMap(_.extras)
+      tmpl.body ++ allGenerated.flatMap(_.forwarders)
     )
   }