Synthesize productElement in SyntheticMethods instead of Desugaring

The implementation needed changes since Desugaring uses `untpd._` while
SyntheticMethods uses `tpd._`. `productArity` is also removed from
Desugaring, it's already implement in SyntheticMethods, so no changes there.

Author: OlivierBlanvillain

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

@@ -27,9 +27,7 @@ object desugar {
 
   /** Names of methods that are added unconditionally to case classes */
   def isDesugaredCaseClassMethodName(name: Name)(implicit ctx: Context): Boolean =
-    name == nme.copy ||
-    name == nme.productArity ||
-    name.isSelectorName
+    name == nme.copy || name.isSelectorName
 
 // ----- DerivedTypeTrees -----------------------------------
 
@@ -361,31 +359,12 @@ object desugar {
     //              pN: TN = pN: @uncheckedVariance)(moreParams) =
     //       new C[...](p1, ..., pN)(moreParams)
     //
-    // To add to both case classes and objects
-    //     def productArity = N
-    //     def productElement(i: Int): Any = i match { ... }
-    //
     // Note: copy default parameters need @uncheckedVariance; see
     // neg/t1843-variances.scala for a test case. The test would give
     // two errors without @uncheckedVariance, one of them spurious.
     val caseClassMeths = {
       def syntheticProperty(name: TermName, rhs: Tree) =
         DefDef(name, Nil, Nil, TypeTree(), rhs).withMods(synthetic)
-      def productArity = syntheticProperty(nme.productArity, Literal(Constant(arity)))
-      def productElement = {
-        val param = makeSyntheticParameter(tpt = ref(defn.IntType))
-        // case N => _${N + 1}
-        val cases = 0.until(arity).map { i =>
-          CaseDef(Literal(Constant(i)), EmptyTree, Select(This(EmptyTypeIdent), nme.selectorName(i)))
-        }
-        val ioob  = ref(defn.IndexOutOfBoundsException.typeRef)
-        val error = Throw(New(ioob, List(List(Select(refOfDef(param), nme.toString_)))))
-        // case _ => throw new IndexOutOfBoundsException(i.toString)
-        val defaultCase = CaseDef(untpd.Ident(nme.WILDCARD), EmptyTree, error)
-        val body = Match(refOfDef(param), (cases :+ defaultCase).toList)
-        DefDef(nme.productElement, Nil, List(List(param)), TypeTree(defn.AnyType), body)
-          .withMods(synthetic)
-      }
       def productElemMeths = {
         val caseParams = constrVparamss.head.toArray
         for (i <- 0 until arity if nme.selectorName(i) `ne` caseParams(i).name)
@@ -416,9 +395,7 @@ object desugar {
       }
 
       if (isCaseClass)
-        productElement :: productArity :: copyMeths ::: enumTagMeths ::: productElemMeths.toList
-      else if (isCaseObject)
-        productArity :: productElement :: Nil
+        copyMeths ::: enumTagMeths ::: productElemMeths.toList
       else Nil
     }
 

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

@@ -525,6 +525,8 @@ class Definitions {
     def Product_canEqual(implicit ctx: Context) = Product_canEqualR.symbol
     lazy val Product_productArityR = ProductClass.requiredMethodRef(nme.productArity)
     def Product_productArity(implicit ctx: Context) = Product_productArityR.symbol
+    lazy val Product_productElementR = ProductClass.requiredMethodRef(nme.productElement)
+    def Product_productElement(implicit ctx: Context) = Product_productElementR.symbol
     lazy val Product_productPrefixR = ProductClass.requiredMethodRef(nme.productPrefix)
     def Product_productPrefix(implicit ctx: Context) = Product_productPrefixR.symbol
   lazy val LanguageModuleRef = ctx.requiredModule("scala.language")

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

@@ -23,6 +23,7 @@ import scala.language.postfixOps
  *    def hashCode(): Int
  *    def canEqual(other: Any): Boolean
  *    def toString(): String
+ *    def productElement(i: Int): Any
  *    def productArity: Int
  *    def productPrefix: String
  *  Special handling:
@@ -44,7 +45,7 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
     if (myValueSymbols.isEmpty) {
       myValueSymbols = List(defn.Any_hashCode, defn.Any_equals)
       myCaseSymbols = myValueSymbols ++ List(defn.Any_toString, defn.Product_canEqual,
-        defn.Product_productArity, defn.Product_productPrefix)
+        defn.Product_productArity, defn.Product_productPrefix, defn.Product_productElement)
     }
 
   def valueSymbols(implicit ctx: Context) = { initSymbols; myValueSymbols }
@@ -91,11 +92,47 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
         case nme.canEqual_ => vrefss => canEqualBody(vrefss.head.head)
         case nme.productArity => vrefss => Literal(Constant(accessors.length))
         case nme.productPrefix => ownName
+        case nme.productElement => vrefss => productElementBody(accessors.length, vrefss.head.head)
       }
       ctx.log(s"adding $synthetic to $clazz at ${ctx.phase}")
       DefDef(synthetic, syntheticRHS(ctx.withOwner(synthetic)))
     }
 
+    /** The class
+     *
+     *  ```
+     *  case class C(x: T, y: T)
+     *  ```
+     *
+     *  gets the `productElement` method:
+     *
+     *  ```
+     *  def productElement(index: Int): Any = index match {
+     *    case 0 => this._1
+     *    case 1 => this._2
+     *    case _ => throw new IndexOutOfBoundsException(index.toString)
+     *  }
+     *  ```
+     */
+    def productElementBody(arity: Int, index: Tree)(implicit ctx: Context): Tree = {
+      val ioob = defn.IndexOutOfBoundsException.typeRef
+      // That's not ioob.typeSymbol.primaryConstructor, this is the other one
+      // that takes a String argument.
+      val constructor = ioob.typeSymbol.info.decls.toList.tail.head.asTerm
+      val stringIndex = Apply(Select(index, nme.toString_), Nil)
+      val error = Throw(New(ioob, constructor, List(stringIndex)))
+
+      // case _ => throw new IndexOutOfBoundsException(i.toString)
+      val defaultCase = CaseDef(Underscore(defn.IntType), EmptyTree, error)
+
+      // case N => _${N + 1}
+      val cases = 0.until(arity).map { i =>
+        CaseDef(Literal(Constant(i)), EmptyTree, Select(This(clazz), nme.selectorName(i)))
+      }
+
+      Match(index, (cases :+ defaultCase).toList)
+    }
+
     /** The class
      *
      *      case class C(x: T, y: U)