Fix #9011: Make single enum values inherit from Product

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

@@ -124,7 +124,7 @@ object DesugarEnums {
 
   /** A creation method for a value of enum type `E`, which is defined as follows:
    *
-   *   private def $new(_$ordinal: Int, $name: String) = new E {
+   *   private def $new(_$ordinal: Int, $name: String) = new E with scala.runtime.EnumValue {
    *     def $ordinal = $tag
    *     override def toString = $name
    *     $values.register(this)
@@ -135,7 +135,7 @@ object DesugarEnums {
     val toStringDef = toStringMeth(Ident(nme.nameDollar))
     val creator = New(Template(
       constr = emptyConstructor,
-      parents = enumClassRef :: Nil,
+      parents = enumClassRef :: scalaRuntimeDot(tpnme.EnumValue) :: Nil,
       derived = Nil,
       self = EmptyValDef,
       body = List(ordinalDef, toStringDef) ++ registerCall
@@ -286,7 +286,9 @@ object DesugarEnums {
       val (tag, scaffolding) = nextOrdinal(CaseKind.Object)
       val ordinalDef = ordinalMethLit(tag)
       val toStringDef = toStringMethLit(name.toString)
-      val impl1 = cpy.Template(impl)(body = List(ordinalDef, toStringDef) ++ registerCall)
+      val impl1 = cpy.Template(impl)(
+        parents = impl.parents :+ scalaRuntimeDot(tpnme.EnumValue),
+        body = List(ordinalDef, toStringDef) ++ registerCall)
         .withAttachment(ExtendsSingletonMirror, ())
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods.withAddedFlags(EnumValue, span))
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)

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

@@ -450,6 +450,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def rootDot(name: Name)(implicit src: SourceFile): Select = Select(Ident(nme.ROOTPKG), name)
   def scalaDot(name: Name)(implicit src: SourceFile): Select = Select(rootDot(nme.scala), name)
   def scalaAnnotationDot(name: Name)(using SourceFile): Select = Select(scalaDot(nme.annotation), name)
+  def scalaRuntimeDot(name: Name)(using SourceFile): Select = Select(scalaDot(nme.runtime), name)
   def scalaUnit(implicit src: SourceFile): Select = scalaDot(tpnme.Unit)
   def scalaAny(implicit src: SourceFile): Select = scalaDot(tpnme.Any)
   def javaDotLangDot(name: Name)(implicit src: SourceFile): Select = Select(Select(Ident(nme.java), nme.lang), name)

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

@@ -300,6 +300,8 @@ trait ConstraintHandling[AbstractContext] {
    *      (i.e. `inst.widenSingletons <:< bound` succeeds with satisfiable constraint)
    *   2. If `inst` is a union type, approximate the union type from above by an intersection
    *      of all common base types, provided the result is a subtype of `bound`.
+   *   3. (currently not enabled, see #9028) If `inst` is an intersection with some restricted base types, drop
+   *      the restricted base types from the intersection, provided the result is a subtype of `bound`.
    *
    *  Don't do these widenings if `bound` is a subtype of `scala.Singleton`.
    *  Also, if the result of these widenings is a TypeRef to a module class,
@@ -309,26 +311,48 @@ trait ConstraintHandling[AbstractContext] {
    * At this point we also drop the @Repeated annotation to avoid inferring type arguments with it,
    * as those could leak the annotation to users (see run/inferred-repeated-result).
    */
-  def widenInferred(inst: Type, bound: Type)(implicit actx: AbstractContext): Type = {
-    def widenOr(tp: Type) = {
+  def widenInferred(inst: Type, bound: Type)(implicit actx: AbstractContext): Type =
+
+    def isRestricted(tp: Type) = tp.typeSymbol == defn.EnumValueClass // for now, to be generalized later
+
+    def dropRestricted(tp: Type): Type = tp.dealias match
+      case tpd @ AndType(tp1, tp2) =>
+        if isRestricted(tp1) then tp2
+        else if isRestricted(tp2) then tp1
+        else
+          val tpw = tpd.derivedAndType(dropRestricted(tp1), dropRestricted(tp2))
+          if tpw ne tpd then tpw else tp
+      case _ =>
+        tp
+
+    def widenRestricted(tp: Type) =
+      val tpw = dropRestricted(tp)
+      if (tpw ne tp) && (tpw <:< bound) then tpw else tp
+
+    def widenOr(tp: Type) =
       val tpw = tp.widenUnion
       if (tpw ne tp) && (tpw <:< bound) then tpw else tp
-    }
-    def widenSingle(tp: Type) = {
+
+    def widenSingle(tp: Type) =
       val tpw = tp.widenSingletons
       if (tpw ne tp) && (tpw <:< bound) then tpw else tp
-    }
+
     def isSingleton(tp: Type): Boolean = tp match
       case WildcardType(optBounds) => optBounds.exists && isSingleton(optBounds.bounds.hi)
       case _ => isSubTypeWhenFrozen(tp, defn.SingletonType)
+
     val wideInst =
-      if isSingleton(bound) then inst else widenOr(widenSingle(inst))
+      if isSingleton(bound) then inst
+      else /*widenRestricted*/(widenOr(widenSingle(inst)))
+        // widenRestricted is currently not called since it's special cased in `dropEnumValue`
+        // in `Namer`. It's left in here in case we want to generalize the scheme to other
+        // "protected inheritance" classes.
     wideInst match
       case wideInst: TypeRef if wideInst.symbol.is(Module) =>
         TermRef(wideInst.prefix, wideInst.symbol.sourceModule)
       case _ =>
         wideInst.dropRepeatedAnnot
-  }
+  end widenInferred
 
   /** The instance type of `param` in the current constraint (which contains `param`).
    *  If `fromBelow` is true, the instance type is the lub of the parameter's

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

@@ -639,6 +639,7 @@ class Definitions {
   @tu lazy val EnumClass: ClassSymbol = ctx.requiredClass("scala.Enum")
     @tu lazy val Enum_ordinal: Symbol = EnumClass.requiredMethod(nme.ordinal)
 
+  @tu lazy val EnumValueClass: ClassSymbol = ctx.requiredClass("scala.runtime.EnumValue")
   @tu lazy val EnumValuesClass: ClassSymbol = ctx.requiredClass("scala.runtime.EnumValues")
   @tu lazy val ProductClass: ClassSymbol = ctx.requiredClass("scala.Product")
     @tu lazy val Product_canEqual          : Symbol = ProductClass.requiredMethod(nme.canEqual_)

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

@@ -438,7 +438,7 @@ object Flags {
    *  TODO: Should check that FromStartFlags do not change in completion
    */
   val FromStartFlags: FlagSet = commonFlags(
-    Module, Package, Deferred, Method, Case,
+    Module, Package, Deferred, Method, Case, Enum,
     HigherKinded, Param, ParamAccessor,
     Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,

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

@@ -357,15 +357,14 @@ object StdNames {
     val CAP: N                  = "CAP"
     val Constant: N             = "Constant"
     val ConstantType: N         = "ConstantType"
-    val doubleHash: N           = "doubleHash"
+    val EnumValue: N            = "EnumValue"
     val ExistentialTypeTree: N  = "ExistentialTypeTree"
     val Flag : N                = "Flag"
     val floatHash: N            = "floatHash"
     val Ident: N                = "Ident"
     val Import: N               = "Import"
     val Literal: N              = "Literal"
     val LiteralAnnotArg: N      = "LiteralAnnotArg"
-    val longHash: N             = "longHash"
     val MatchCase: N            = "MatchCase"
     val MirroredElemTypes: N    = "MirroredElemTypes"
     val MirroredElemLabels: N   = "MirroredElemLabels"
@@ -443,6 +442,7 @@ object StdNames {
     val delayedInitArg: N       = "delayedInit$body"
     val derived: N              = "derived"
     val derives: N              = "derives"
+    val doubleHash: N           = "doubleHash"
     val drop: N                 = "drop"
     val dynamics: N             = "dynamics"
     val elem: N                 = "elem"
@@ -505,6 +505,7 @@ object StdNames {
     val language: N             = "language"
     val length: N               = "length"
     val lengthCompare: N        = "lengthCompare"
+    val longHash: N             = "longHash"
     val macroThis : N           = "_this"
     val macroContext : N        = "c"
     val main: N                 = "main"

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

@@ -1439,6 +1439,19 @@ class Namer { typer: Typer =>
       // println(s"owner = ${sym.owner}, decls = ${sym.owner.info.decls.show}")
       def isInlineVal = sym.isOneOf(FinalOrInline, butNot = Method | Mutable)
 
+      def isEnumValue(tp: Type) = tp.typeSymbol == defn.EnumValueClass
+
+      // Drop EnumValue parents from inferred types of enum constants
+      def dropEnumValue(tp: Type): Type = tp.dealias match
+        case tpd @ AndType(tp1, tp2) =>
+          if isEnumValue(tp1) then tp2
+          else if isEnumValue(tp2) then tp1
+          else
+            val tpw = tpd.derivedAndType(dropEnumValue(tp1), dropEnumValue(tp2))
+            if tpw ne tpd then tpw else tp
+        case _ =>
+          tp
+
       // Widen rhs type and eliminate `|' but keep ConstantTypes if
       // definition is inline (i.e. final in Scala2) and keep module singleton types
       // instead of widening to the underlying module class types.
@@ -1447,7 +1460,9 @@ class Namer { typer: Typer =>
       def widenRhs(tp: Type): Type =
         tp.widenTermRefExpr.simplified match
           case ctp: ConstantType if isInlineVal => ctp
-          case tp => ctx.typeComparer.widenInferred(tp, rhsProto)
+          case tp =>
+            val tp1 = ctx.typeComparer.widenInferred(tp, rhsProto)
+            if sym.is(Enum) then dropEnumValue(tp1) else tp1
 
       // Replace aliases to Unit by Unit itself. If we leave the alias in
       // it would be erased to BoxedUnit.

docs/docs/reference/enums/desugarEnums.md

@@ -126,7 +126,9 @@ map into `case class`es or `val`s.
    where `n` is the ordinal number of the case in the companion object,
    starting from 0.  The statement `$values.register(this)` registers the value
    as one of the `values` of the enumeration (see below). `$values` is a
-   compiler-defined private value in the companion object.
+   compiler-defined private value in the companion object. The anonymous class also
+   implements the abstract `Product` methods that it inherits from `Enum`.
+
 
    It is an error if a value case refers to a type parameter of the enclosing `enum`
    in a type argument of `<parents>`.
@@ -178,6 +180,7 @@ Companion objects of enumerations that contain at least one simple case define i
      }
      ```
 
+The anonymous class also implements the abstract `Product` methods that it inherits from `Enum`.
 The `$ordinal` method above is used to generate the `ordinal` method if the enum does not extend a `java.lang.Enum` (as Scala enums do not extend `java.lang.Enum`s unless explicitly specified). In case it does, there is no need to generate `ordinal` as `java.lang.Enum` defines it.
 
 ### Scopes for Enum Cases

docs/docs/reference/enums/enums.md

@@ -95,7 +95,7 @@ If you want to use the Scala-defined enums as Java enums, you can do so by exten
 enum Color extends java.lang.Enum[Color] { case Red, Green, Blue }
 ```
 
-The type parameter comes from the Java enum [definition](https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/Enum.html) and should be the same as the type of the enum. 
+The type parameter comes from the Java enum [definition](https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/Enum.html) and should be the same as the type of the enum.
 There is no need to provide constructor arguments (as defined in the Java API docs) to `java.lang.Enum` when extending it – the compiler will generate them automatically.
 
 After defining `Color` like that, you can use it like you would a Java enum:
@@ -116,7 +116,7 @@ This trait defines a single public method, `ordinal`:
 package scala
 
 /** A base trait of all enum classes */
-trait Enum {
+trait Enum extends Product with Serializable {
 
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int

library/src-bootstrapped/scala/Enum.scala

@@ -0,0 +1,9 @@
+package scala
+
+/** A base trait of all enum classes */
+trait Enum extends Product, Serializable:
+
+  /** A number uniquely identifying a case of an enum */
+  def ordinal: Int
+  protected def $ordinal: Int
+

library/src/scala/Enum.scala → library/src-non-bootstrapped/Enum.scala

@@ -1,9 +1,8 @@
 package scala
 
 /** A base trait of all enum classes */
-trait Enum {
+trait Enum:
 
   /** A number uniquely identifying a case of an enum */
   def ordinal: Int
   protected def $ordinal: Int
-}

library/src/scala/runtime/EnumValue.scala

@@ -0,0 +1,10 @@
+package scala.runtime
+
+trait EnumValue extends Product, Serializable:
+  override def canEqual(that: Any) = this eq that.asInstanceOf[AnyRef]
+  override def productArity: Int = 0
+  override def productPrefix: String = toString
+  override def productElement(n: Int): Any =
+    throw IndexOutOfBoundsException(n.toString)
+  override def productElementName(n: Int): String =
+    throw IndexOutOfBoundsException(n.toString)

tests/fuzzy/b82054893e0db44e31ae82d696c19c1fbc7be55c.scala

@@ -1,4 +1,4 @@
-object main {
+object _main {
 def i0 = {
 class i1 {
 private[i0] var i2: _ > 0 private def i3: List[Int]

tests/neg/enumvalues.scala

@@ -0,0 +1,15 @@
+enum Color:
+  case Red, Green, Blue
+
+enum Option[+T]:
+  case None extends Option[Nothing]
+
+import scala.runtime.EnumValue
+
+@main def Test(c: Boolean) =
+  // Verify that enum constants don't leak the scala.runtime.EnumValue trait
+  val x: EnumValue = if c then Color.Red else Color.Blue // error // error
+  val y: EnumValue = Color.Green        // error
+  val z: EnumValue = Option.None        // error
+
+

tests/pos/enum-List-control.scala

@@ -2,11 +2,16 @@ abstract sealed class List[T] extends Enum
 object List {
   final class Cons[T](x: T, xs: List[T]) extends List[T] {
     def $ordinal = 0
+    def canEqual(that: Any): Boolean = that.isInstanceOf[Cons[_]]
+    def productArity: Int = 2
+    def productElement(n: Int): Any = n match
+      case 0 => x
+      case 1 => xs
   }
   object Cons {
     def apply[T](x: T, xs: List[T]): List[T] = new Cons(x, xs)
   }
-  final class Nil[T]() extends List[T] {
+  final class Nil[T]() extends List[T], runtime.EnumValue {
     def $ordinal = 1
   }
   object Nil {

tests/pos/localmodules.scala

@@ -1,6 +1,6 @@
 package test;
 
-object main {
+object _main {
 
   class a {
 

tests/pos/t0002.scala

@@ -1,4 +1,4 @@
-object main {
+object _main {
   def main(args: Array[String]) = {
     val b = true;
     while (b == true) { }

tests/pos/t789.scala

@@ -1,4 +1,4 @@
-object main { // don't do this at home
+object _main { // don't do this at home
 
   trait Impl
 

tests/pos/typealiases.scala

@@ -11,7 +11,7 @@ trait Test[T] {
   def check2[S](xs: Array[S], c: Check[S]) = c(xs)
 }
 
-object main extends Test[Int] {
+object _main extends Test[Int] {
   val pair1 = (1,1)
 
   implicit def topair(x: Int): Tuple2[Int, Int] = (x,x)

tests/run/i9011.scala

@@ -0,0 +1,57 @@
+enum Opt[+T] derives Eq:
+  case Sm(t: T)
+  case Nn
+
+import scala.deriving._
+import scala.compiletime.{erasedValue, summonInline}
+
+trait Eq[T] {
+  def eqv(x: T, y: T): Boolean
+}
+
+object Eq {
+  given Eq[Int] {
+    def eqv(x: Int, y: Int) = x == y
+  }
+
+  inline def summonAll[T <: Tuple]: List[Eq[_]] = inline erasedValue[T] match {
+    case _: Unit => Nil
+    case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
+  }
+
+  def check(elem: Eq[_])(x: Any, y: Any): Boolean =
+    elem.asInstanceOf[Eq[Any]].eqv(x, y)
+
+  def iterator[T](p: T) = p.asInstanceOf[Product].productIterator
+
+  def eqSum[T](s: Mirror.SumOf[T], elems: List[Eq[_]]): Eq[T] =
+    new Eq[T] {
+      def eqv(x: T, y: T): Boolean = {
+        val ordx = s.ordinal(x)
+        (s.ordinal(y) == ordx) && check(elems(ordx))(x, y)
+      }
+    }
+
+  def eqProduct[T](p: Mirror.ProductOf[T], elems: List[Eq[_]]): Eq[T] =
+    new Eq[T] {
+      def eqv(x: T, y: T): Boolean =
+        iterator(x).zip(iterator(y)).zip(elems.iterator).forall {
+          case ((x, y), elem) => check(elem)(x, y)
+        }
+    }
+
+  inline given derived[T](using m: Mirror.Of[T]) as Eq[T] = {
+    val elemInstances = summonAll[m.MirroredElemTypes]
+    inline m match {
+      case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
+      case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
+    }
+  }
+}
+
+object Test extends App {
+  import Opt._
+  val eqoi = summon[Eq[Opt[Int]]]
+  assert(eqoi.eqv(Sm(23), Sm(23)))
+  assert(eqoi.eqv(Nn, Nn))
+}