Remove ProductN parent on case classes

This means the compiler needs to systematically synthesise productElement and
productArity, which aligns with what scalac is doing.

This change gets rid of last reference to scala.ProductN! 🎉

Author: OlivierBlanvillain

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

@@ -291,7 +291,8 @@ object desugar {
       case _ => false
     }
 
-    val isCaseClass = mods.is(Case) && !mods.is(Module)
+    val isCaseClass  = mods.is(Case) && !mods.is(Module)
+    val isCaseObject = mods.is(Case) && mods.is(Module)
     val isEnum = mods.hasMod[Mod.Enum]
     val isEnumCase = isLegalEnumCase(cdef)
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
@@ -360,7 +361,7 @@ object desugar {
     //              pN: TN = pN: @uncheckedVariance)(moreParams) =
     //       new C[...](p1, ..., pN)(moreParams)
     //
-    // Above arity 22 we also synthesize:
+    // To add to both case classes and objects
     //     def productArity = N
     //     def productElement(i: Int): Any = i match { ... }
     //
@@ -414,33 +415,21 @@ object desugar {
         }
       }
 
-      // Above MaxTupleArity we extend Product instead of ProductN, in this
-      // case we need to synthesise productElement & productArity.
-      def largeProductMeths =
-        if (arity > Definitions.MaxTupleArity) productElement :: productArity :: Nil
-        else Nil
-
       if (isCaseClass)
-        largeProductMeths ::: copyMeths ::: enumTagMeths ::: productElemMeths.toList
+        productElement :: productArity :: copyMeths ::: enumTagMeths ::: productElemMeths.toList
+      else if (isCaseObject)
+        productArity :: productElement :: Nil
       else Nil
     }
 
     def anyRef = ref(defn.AnyRefAlias.typeRef)
-    def productConstr(n: Int) = {
-      val tycon = scalaDot((str.Product + n).toTypeName)
-      val targs = constrVparamss.head map (_.tpt)
-      if (targs.isEmpty) tycon else AppliedTypeTree(tycon, targs)
-    }
-    def product =
-      if (arity > Definitions.MaxTupleArity) scalaDot(str.Product.toTypeName)
-      else productConstr(arity)
 
-    // Case classes and case objects get Product/ProductN parents
+    // Case classes and case objects get Product parents
     var parents1 = parents
     if (isEnumCase && parents.isEmpty)
       parents1 = enumClassTypeRef :: Nil
-    if (mods.is(Case))
-      parents1 = parents1 :+ product // TODO: This also adds Product0 to case objects. Do we want that?
+    if (isCaseClass | isCaseObject)
+      parents1 = parents1 :+ scalaDot(str.Product.toTypeName)
     if (isEnum)
       parents1 = parents1 :+ ref(defn.EnumType)
 
@@ -499,7 +488,6 @@ object desugar {
         companionDefs(anyRef, Nil)
       else Nil
 
-
     // For an implicit class C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, .., pMN: TMN), the method
     //     synthetic implicit C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, ..., pMN: TMN): C[Ts] =
     //       new C[Ts](p11, ..., p1N) ... (pM1, ..., pMN) =

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

@@ -700,7 +700,6 @@ class Definitions {
   def FunctionClassPerRun = new PerRun[Array[Symbol]](implicit ctx => ImplementedFunctionType.map(_.symbol.asClass))
 
   lazy val TupleType = mkArityArray("scala.Tuple", MaxTupleArity, 2)
-  lazy val ProductNType = mkArityArray("scala.Product", MaxTupleArity, 0)
 
   def FunctionClass(n: Int, isImplicit: Boolean = false)(implicit ctx: Context) =
     if (isImplicit) ctx.requiredClass("scala.ImplicitFunction" + n.toString)
@@ -715,7 +714,6 @@ class Definitions {
     else FunctionClass(n, isImplicit).typeRef
 
   private lazy val TupleTypes: Set[TypeRef] = TupleType.toSet
-  private lazy val ProductTypes: Set[TypeRef] = ProductNType.toSet
 
   /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
   def scalaClassName(cls: Symbol)(implicit ctx: Context): TypeName =

tests/neg/t1843-variances.scala

@@ -6,7 +6,7 @@
 
 object Crash {
   trait UpdateType[A]
-  case class StateUpdate[+A](updateType : UpdateType[A], value : A) // error
+  case class StateUpdate[+A](updateType : UpdateType[A], value : A) // error // error
   case object IntegerUpdateType extends UpdateType[Integer]
 
   //However this method will cause a crash