Generate sum mirrors for sealed traits that do not have a companion

Author: odersky

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

@@ -8,6 +8,7 @@ import Symbols._, StdNames._, Trees._
 import Decorators._
 import util.{Property, SourceFile}
 import typer.ErrorReporting._
+import transform.SyntheticMembers.ExtendsSingletonMirror
 
 import scala.annotation.internal.sharable
 
@@ -22,9 +23,6 @@ object DesugarEnums {
   /** Attachment containing the number of enum cases and the smallest kind that was seen so far. */
   val EnumCaseCount: Property.Key[(Int, DesugarEnums.CaseKind.Value)] = new Property.Key
 
-  /** Attachment marking an anonymous class as a singleton case. */
-  val SingletonCase: Property.StickyKey[Unit] = new Property.StickyKey
-
   /** The enumeration class that belongs to an enum case. This works no matter
    *  whether the case is still in the enum class or it has been transferred to the
    *  companion object.
@@ -124,7 +122,7 @@ object DesugarEnums {
       derived = Nil,
       self = EmptyValDef,
       body = List(enumTagDef, toStringDef) ++ registerCall
-    ).withAttachment(SingletonCase, ()))
+    ).withAttachment(ExtendsSingletonMirror, ()))
     DefDef(nme.DOLLAR_NEW, Nil,
         List(List(param(nme.tag, defn.IntType), param(nme.name, defn.StringType))),
         TypeTree(), creator).withFlags(Private | Synthetic)
@@ -267,7 +265,7 @@ object DesugarEnums {
           .withFlags(Override)
       val (tagMeth, scaffolding) = enumTagMeth(CaseKind.Object)
       val impl1 = cpy.Template(impl)(body = List(tagMeth, toStringMeth) ++ registerCall)
-        .withAttachment(SingletonCase, ())
+        .withAttachment(ExtendsSingletonMirror, ())
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods | Final)
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
     }

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

@@ -10,11 +10,20 @@ import NameOps._
 import Annotations.Annotation
 import typer.ProtoTypes.constrained
 import ast.untpd
-import ast.DesugarEnums.SingletonCase
 import ValueClasses.isDerivedValueClass
 import SymUtils._
+import util.Property
 import config.Printers.derive
 
+object SyntheticMembers {
+
+  /** Attachment marking an anonymous class as a singleton case that will extend from Mirror.Singleton. */
+  val ExtendsSingletonMirror: Property.StickyKey[Unit] = new Property.StickyKey
+
+  /** Attachment marking an anonymous class as a sum mirror that will extends from Mirror.Sum. */
+  val ExtendsSumMirror: Property.StickyKey[Unit] = new Property.StickyKey
+}
+
 /** Synthetic method implementations for case classes, case objects,
  *  and value classes.
  *
@@ -38,6 +47,7 @@ import config.Printers.derive
  *    def hashCode(): Int
  */
 class SyntheticMembers(thisPhase: DenotTransformer) {
+  import SyntheticMembers._
   import ast.tpd._
 
   private[this] var myValueSymbols: List[Symbol] = Nil
@@ -381,7 +391,6 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
    */
   def addMirrorSupport(impl: Template)(implicit ctx: Context): Template = {
     val clazz = ctx.owner.asClass
-    val linked = clazz.linkedClass
 
     var newBody = impl.body
     var newParents = impl.parents
@@ -392,40 +401,56 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         classParents = oldClassInfo.classParents :+ parent)
       clazz.copySymDenotation(info = newClassInfo).installAfter(thisPhase)
     }
-    def addMethod(name: TermName, info: Type, body: (Symbol, Tree, Context) => Tree): Unit = {
+    def addMethod(name: TermName, info: Type, cls: Symbol, body: (Symbol, Tree, Context) => Tree): Unit = {
       val meth = ctx.newSymbol(clazz, name, Synthetic | Method, info, coord = clazz.coord)
       if (!existingDef(meth, clazz).exists) {
         meth.entered
         newBody = newBody :+
-          synthesizeDef(meth, vrefss => ctx => body(linked, vrefss.head.head, ctx))
+          synthesizeDef(meth, vrefss => ctx => body(cls, vrefss.head.head, ctx))
       }
     }
+    val linked = clazz.linkedClass
     lazy val monoType = {
-      val monoType =
-        ctx.newSymbol(clazz, tpnme.MonoType, Synthetic, TypeAlias(linked.rawTypeRef), coord = clazz.coord)
-      existingDef(monoType, clazz).orElse {
+      val existing = clazz.info.member(tpnme.MonoType).symbol
+      if (existing.exists && !existing.is(Deferred)) existing
+      else {
+        val monoType =
+          ctx.newSymbol(clazz, tpnme.MonoType, Synthetic, TypeAlias(linked.rawTypeRef), coord = clazz.coord)
         newBody = newBody :+ TypeDef(monoType).withSpan(ctx.owner.span.focus)
         monoType.entered
       }
     }
+    def makeSingletonMirror() =
+      addParent(defn.Mirror_SingletonType)
+    def makeProductMirror() = {
+      addParent(defn.Mirror_ProductType)
+      addMethod(
+        nme.fromProduct,
+        MethodType(defn.ProductType :: Nil, monoType.typeRef),
+        linked,
+        fromProductBody(_, _)(_).ensureConforms(monoType.typeRef))  // t4758.scala or i3381.scala are examples where a cast is needed
+    }
+    def makeSumMirror(cls: Symbol) = {
+      addParent(defn.Mirror_SumType)
+      addMethod(
+        nme.ordinal,
+        MethodType(monoType.typeRef :: Nil, defn.IntType),
+        cls,
+        ordinalBody(_, _)(_))
+    }
+
     if (clazz.is(Module)) {
-      if (clazz.is(Case))
-        addParent(defn.Mirror_SingletonType)
-      else if (linked.isGenericProduct) {
-        addParent(defn.Mirror_ProductType)
-        addMethod(nme.fromProduct, MethodType(defn.ProductType :: Nil, monoType.typeRef),
-          fromProductBody(_, _)(_).ensureConforms(monoType.typeRef))  // t4758.scala or i3381.scala are examples where a cast is needed
-      }
-      else if (linked.isGenericSum) {
-        addParent(defn.Mirror_SumType)
-        addMethod(nme.ordinal, MethodType(monoType.typeRef :: Nil, defn.IntType),
-          ordinalBody(_, _)(_))
-      }
+      if (clazz.is(Case)) makeSingletonMirror()
+      else if (linked.isGenericProduct) makeProductMirror()
+      else if (linked.isGenericSum) makeSumMirror(linked)
       else if (linked.is(Sealed))
         derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum}")
     }
-    else if (impl.removeAttachment(SingletonCase).isDefined)
-      addParent(defn.Mirror_SingletonType)
+    else if (impl.removeAttachment(ExtendsSingletonMirror).isDefined)
+      makeSingletonMirror()
+    else if (impl.removeAttachment(ExtendsSumMirror).isDefined)
+      makeSumMirror(monoType.typeRef.dealias.classSymbol)
+
     cpy.Template(impl)(parents = newParents, body = newBody)
   }
 

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

@@ -3,7 +3,7 @@ package dotc
 package typer
 
 import core._
-import ast.{Trees, TreeTypeMap, untpd, tpd}
+import ast.{Trees, TreeTypeMap, untpd, tpd, DesugarEnums}
 import util.Spans._
 import util.Stats.{track, record, monitored}
 import printing.{Showable, Printer}
@@ -29,6 +29,7 @@ import Inferencing.fullyDefinedType
 import Trees._
 import transform.SymUtils._
 import transform.TypeUtils._
+import transform.SyntheticMembers.ExtendsSumMirror
 import Hashable._
 import util.{Property, SourceFile, NoSource}
 import config.Config
@@ -925,8 +926,22 @@ trait Implicits { self: Typer =>
               .refinedWith(tpnme.MonoType, monoAlias)
               .refinedWith(tpnme.ElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
           var modul = cls.linkedClass.sourceModule
-          if (!modul.exists) ???
-          ref(modul).withSpan(span).cast(mirrorType)
+          val mirrorRef =
+            if (modul.exists) ref(modul).withSpan(span)
+            else {
+              // create an anonymous class `new Object { type MonoType = ... }`
+              // and mark it so that it is made into a `Mirror.Sum` at PostTyper.
+              val monoTypeDef = untpd.TypeDef(tpnme.MonoType, untpd.TypeTree(monoType))
+              val newImpl = untpd.Template(
+                constr = untpd.emptyConstructor,
+                parents = untpd.TypeTree(defn.ObjectType) :: Nil,
+                derived = Nil,
+                self = EmptyValDef,
+                body = monoTypeDef :: Nil
+              ).withAttachment(ExtendsSumMirror, ())
+              typed(untpd.New(newImpl).withSpan(span))
+            }
+          mirrorRef.cast(mirrorType)
         case _ =>
           EmptyTree
       }

tests/run/deriving.check

@@ -2,3 +2,4 @@ A(1,2)
 A(1,2)
 B
 1
+0

tests/run/deriving.scala

@@ -4,6 +4,9 @@ object T
 case class A(x: Int, y: Int) extends T
 case object B extends T
 
+sealed trait U
+case class C() extends U
+
 object Test extends App {
   import deriving.{Mirror, EmptyProduct}
 
@@ -24,4 +27,8 @@ object Test extends App {
     case m: Mirror.SumOf[T] =>
       println(m.ordinal(B))
   }
+  the[Mirror.Of[U]] match {
+    case m: Mirror.SumOf[U] =>
+      println(m.ordinal(C()))
+  }
 }