Refine isGenericSum condition

Author: odersky

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

@@ -13,6 +13,7 @@ import NameKinds._
 import Flags._
 import Annotations._
 import ValueClasses.isDerivedValueClass
+import Decorators._
 
 import language.implicitConversions
 import scala.annotation.tailrec
@@ -78,23 +79,34 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def isGenericProduct(implicit ctx: Context): Boolean = whyNotGenericProduct.isEmpty
 
   /** Is this a sealed class or trait for which a sum mirror is generated?
-   *  Excluded are
+   *  It must satisfy the following conditions:
+   *   - it has at least one child class or object
+   *   - none of its children are anonymous classes
+   *   - all of its children are addressable through a path from its companion object
+   *   - all of its children are generic products or singletons
    */
   def whyNotGenericSum(implicit ctx: Context): String =
     if (!self.is(Sealed))
       s"it is not a sealed ${if (self.is(Trait)) "trait" else "class"}"
     else {
       val children = self.children
-      def problem(child: Symbol) =
+      val companion = self.linkedClass
+      def problem(child: Symbol) = {
+
+        def isAccessible(sym: Symbol): Boolean =
+          companion.isContainedIn(sym) || sym.is(Module) && isAccessible(sym.owner)
+
         if (child == self) "it has anonymous or inaccessible subclasses"
+        else if (!isAccessible(child.owner)) i"its child $child is not accessible"
         else if (!child.isClass) ""
         else {
           val s = child.whyNotGenericProduct
           if (s.isEmpty) s
-          else "its child $child is not a generic product because $s"
+          else i"its child $child is not a generic product because $s"
         }
+      }
       if (children.isEmpty) "it does not have subclasses"
-      else children.filter(_.isClass).map(problem).find(!_.isEmpty).getOrElse("")
+      else children.map(problem).find(!_.isEmpty).getOrElse("")
     }
 
   def isGenericSum(implicit ctx: Context): Boolean = whyNotGenericSum.isEmpty

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

@@ -12,6 +12,7 @@ import typer.ProtoTypes.constrained
 import ast.untpd
 import ValueClasses.isDerivedValueClass
 import SymUtils._
+import config.Printers.derive
 
 /** Synthetic method implementations for case classes, case objects,
  *  and value classes.
@@ -419,8 +420,9 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         addMethod(nme.ordinal, MethodType(monoType.typeRef :: Nil, defn.IntType),
           ordinalBody(_, _)(_))
       }
+      else if (linked.is(Sealed))
+        derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum}")
     }
-
     cpy.Template(impl)(parents = newParents, body = newBody)
   }
 

tests/run/deriving.scala

@@ -0,0 +1,10 @@
+sealed trait T
+object T
+
+case class A(x: Int, y: Int) extends T
+case object B extends T
+
+object Test extends App {
+
+  case class AA[X >: Null <: AnyRef](x: X, y: X, z: String)
+}

tests/run/ordinal-innerclass.scala

@@ -0,0 +1,38 @@
+object Test extends App {
+
+  class A {
+    class B {
+      object O {
+        sealed trait T
+        case class C(x: Int) extends T
+        object T {
+          case class D() extends T
+        }
+      }
+    }
+  }
+
+  val a = new A
+  val b = new a.B
+  val o = b.O
+  val sum: deriving.Mirror.Sum { type MonoType = o.T }= o.T.asInstanceOf
+  assert(sum.ordinal(new o.C(1)) == 0)
+  assert(sum.ordinal(new o.T.D()) == 1)
+
+  object MR {
+    // from betterFiles/ManagedResource: FM should not be treated as a generic sum
+    // since its children are not accessible from its companion object. If it was
+    // treated as a generic sum, ExplicitOuter would crash when compiling the synthesized
+    // `ordinal` method.
+    sealed trait FM
+    object FM {
+      trait I {
+        object fm1 extends FM
+        object fm2 extends FM
+      }
+    }
+  }
+
+  trait T1
+  case class A1() extends T1
+}