Merge pull request #5843 from dotty-staging/derive-multiversal

Base multiversal equality on typeclass derivation

Author: odersky

community-build/community-projects/scalatest

@@ -536,45 +536,6 @@ object desugar {
     if (isEnum)
       parents1 = parents1 :+ ref(defn.EnumType)
 
-    // The Eq instance for an Enum class. For an enum class
-    //
-    //    enum class C[T1, ..., Tn]
-    //
-    // we generate:
-    //
-    //    implicit def eqInstance[T1$1, ..., Tn$1, T1$2, ..., Tn$2](implicit
-    //      ev1: Eq[T1$1, T1$2], ..., evn: Eq[Tn$1, Tn$2]])
-    //      : Eq[C[T1$, ..., Tn$1], C[T1$2, ..., Tn$2]] = Eq
-    //
-    // Higher-kinded type arguments `Ti` are omitted as evidence parameters.
-    //
-    // FIXME: This is too simplistic. Instead of just generating evidence arguments
-    // for every first-kinded type parameter, we should look instead at the
-    // actual types occurring in cases and derive parameters from these. E.g. in
-    //
-    //    enum HK[F[_]] {
-    //      case C1(x: F[Int]) extends HK[F[Int]]
-    //      case C2(y: F[String]) extends HL[F[Int]]
-    //
-    // we would need evidence parameters for `F[Int]` and `F[String]`
-    // We should generate Eq instances with the techniques
-    // of typeclass derivation once that is available.
-    def eqInstance = {
-      val leftParams = constrTparams.map(derivedTypeParam(_, "$1"))
-      val rightParams = constrTparams.map(derivedTypeParam(_, "$2"))
-      val subInstances =
-        for ((param1, param2) <- leftParams `zip` rightParams if !isHK(param1))
-        yield appliedRef(ref(defn.EqType), List(param1, param2), widenHK = true)
-      DefDef(
-          name = nme.eqInstance,
-          tparams = leftParams ++ rightParams,
-          vparamss = if (subInstances.isEmpty) Nil else List(makeImplicitParameters(subInstances)),
-          tpt = appliedTypeTree(ref(defn.EqType),
-              appliedRef(classTycon, leftParams) :: appliedRef(classTycon, rightParams) :: Nil),
-          rhs = ref(defn.EqModule.termRef)).withFlags(Synthetic | Implicit)
-    }
-    def eqInstances = if (isEnum) eqInstance :: Nil else Nil
-
     // derived type classes of non-module classes go to their companions
     val (clsDerived, companionDerived) =
       if (mods.is(Module)) (impl.derived, Nil) else (Nil, impl.derived)
@@ -593,7 +554,7 @@ object desugar {
       mdefs
     }
 
-    val companionMembers = defaultGetters ::: eqInstances ::: enumCases
+    val companionMembers = defaultGetters ::: enumCases
 
     // The companion object definitions, if a companion is needed, Nil otherwise.
     // companion definitions include:
@@ -643,7 +604,7 @@ object desugar {
         }
         companionDefs(companionParent, applyMeths ::: unapplyMeth :: companionMembers)
       }
-      else if (companionMembers.nonEmpty || companionDerived.nonEmpty)
+      else if (companionMembers.nonEmpty || companionDerived.nonEmpty || isEnum)
         companionDefs(anyRef, companionMembers)
       else if (isValueClass) {
         impl.constr.vparamss match {

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

@@ -734,11 +734,11 @@ class Definitions {
   lazy val TastyReflectionModule: TermSymbol = ctx.requiredModule("scala.tasty.Reflection")
     lazy val TastyReflection_macroContext: TermSymbol = TastyReflectionModule.requiredMethod("macroContext")
 
-  lazy val EqType: TypeRef = ctx.requiredClassRef("scala.Eq")
-  def EqClass(implicit ctx: Context): ClassSymbol = EqType.symbol.asClass
-  def EqModule(implicit ctx: Context): Symbol = EqClass.companionModule
+  lazy val EqlType: TypeRef = ctx.requiredClassRef("scala.Eql")
+  def EqlClass(implicit ctx: Context): ClassSymbol = EqlType.symbol.asClass
+  def EqlModule(implicit ctx: Context): Symbol = EqlClass.companionModule
 
-    def Eq_eqAny(implicit ctx: Context): TermSymbol = EqModule.requiredMethod(nme.eqAny)
+    def Eql_eqlAny(implicit ctx: Context): TermSymbol = EqlModule.requiredMethod(nme.eqlAny)
 
   lazy val NotType: TypeRef = ctx.requiredClassRef("scala.implicits.Not")
   def NotClass(implicit ctx: Context): ClassSymbol = NotType.symbol.asClass

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

@@ -67,7 +67,7 @@ import collection.mutable.ListBuffer
  */
 object Denotations {
 
-  implicit def eqDenotation: Eq[Denotation, Denotation] = Eq
+  implicit def eqDenotation: Eql[Denotation, Denotation] = Eql.derived
 
   /** A PreDenotation represents a group of single denotations or a single multi-denotation
    *  It is used as an optimization to avoid forming MultiDenotations too eagerly.

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

@@ -52,6 +52,9 @@ object Mode {
   /** Allow GADTFlexType labelled types to have their bounds adjusted */
   val GADTflexible: Mode = newMode(8, "GADTflexible")
 
+  /** Assume -language:strictEquality */
+  val StrictEquality: Mode = newMode(9, "StrictEquality")
+
   /** We are currently printing something: avoid to produce more logs about
    *  the printing
    */

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

@@ -25,7 +25,7 @@ object Names {
     def toTermName: TermName
   }
 
-  implicit def eqName: Eq[Name, Name] = Eq
+  implicit def eqName: Eql[Name, Name] = Eql.derived
 
   /** A common superclass of Name and Symbol. After bootstrap, this should be
    *  just the type alias Name | Symbol

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

@@ -418,7 +418,7 @@ object StdNames {
     val equals_ : N             = "equals"
     val error: N                = "error"
     val eval: N                 = "eval"
-    val eqAny: N                = "eqAny"
+    val eqlAny: N               = "eqlAny"
     val ex: N                   = "ex"
     val experimental: N         = "experimental"
     val f: N                    = "f"

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

@@ -406,7 +406,7 @@ trait Symbols { this: Context =>
 
 object Symbols {
 
-  implicit def eqSymbol: Eq[Symbol, Symbol] = Eq
+  implicit def eqSymbol: Eql[Symbol, Symbol] = Eql.derived
 
   /** Tree attachment containing the identifiers in a tree as a sorted array */
   val Ids: Property.Key[Array[String]] = new Property.Key

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

@@ -40,7 +40,7 @@ object Types {
 
   @sharable private[this] var nextId = 0
 
-  implicit def eqType: Eq[Type, Type] = Eq
+  implicit def eqType: Eql[Type, Type] = Eql.derived
 
   /** Main class representing types.
    *

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

@@ -193,7 +193,7 @@ trait Deriving { this: Typer =>
           if (nparams == 0) Nil
           else if (nparams == 1) tparam :: Nil
           else typeClass.typeParams.map(tcparam =>
-            tparam.copy(name = s"${tparam.name}_${tcparam.name}".toTypeName)
+            tparam.copy(name = s"${tparam.name}_$$_${tcparam.name}".toTypeName)
               .asInstanceOf[TypeSymbol])
         }
         val firstKindedParamss = clsParamss.filter {