recursively check for product ctor accessibility

Author: bishabosha

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

@@ -82,11 +82,26 @@ object SymUtils:
     *  parameter section.
     */
     def whyNotGenericProduct(using Context): String =
+      /** for a case class, if it will have an anonymous mirror,
+       *  check that its constructor can be accessed
+       *  from the calling scope.
+       */
+      def canAccessCtor: Boolean =
+        def isAccessible(sym: Symbol): Boolean = ctx.owner.isContainedIn(sym)
+        def isSub(sym: Symbol): Boolean = ctx.owner.ownersIterator.exists(_.derivesFrom(sym))
+        val ctor = self.primaryConstructor
+        (!ctor.isOneOf(Private | Protected) || isSub(self)) // we cant access the ctor because we do not extend cls
+        && (!ctor.privateWithin.exists || isAccessible(ctor.privateWithin)) // check scope is compatible
+
+
+      val companionMirror = self.useCompanionAsProductMirror
       if (!self.is(CaseClass)) "it is not a case class"
       else if (self.is(Abstract)) "it is an abstract class"
       else if (self.primaryConstructor.info.paramInfoss.length != 1) "it takes more than one parameter list"
       else if (isDerivedValueClass(self)) "it is a value class"
+      else if (!(companionMirror || canAccessCtor)) s"the constructor of $self is innaccessible from the calling scope."
       else ""
+    end whyNotGenericProduct
 
     def isGenericProduct(using Context): Boolean = whyNotGenericProduct.isEmpty
 
@@ -120,6 +135,9 @@ object SymUtils:
       self.isOneOf(FinalOrInline, butNot = Mutable)
       && (!self.is(Method) || self.is(Accessor))
 
+    def useCompanionAsProductMirror(using Context): Boolean =
+      self.linkedClass.exists && !self.is(Scala2x) && !self.linkedClass.is(Case)
+
     def useCompanionAsSumMirror(using Context): Boolean =
       def companionExtendsSum(using Context): Boolean =
         self.linkedClass.isSubClass(defn.Mirror_SumClass)
@@ -145,39 +163,39 @@ object SymUtils:
     *     and also the location of the generated mirror.
     *   - all of its children are generic products, singletons, or generic sums themselves.
     */
-    def whyNotGenericSum(declScope: Symbol)(using Context): String =
+    def whyNotGenericSum(using Context): String =
       if (!self.is(Sealed))
         s"it is not a sealed ${self.kindString}"
       else if (!self.isOneOf(AbstractOrTrait))
         "it is not an abstract class"
       else {
         val children = self.children
         val companionMirror = self.useCompanionAsSumMirror
-        assert(!(companionMirror && (declScope ne self.linkedClass)))
         def problem(child: Symbol) = {
 
           def isAccessible(sym: Symbol): Boolean =
-            (self.isContainedIn(sym) && (companionMirror || declScope.isContainedIn(sym)))
+            (self.isContainedIn(sym) && (companionMirror || ctx.owner.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 if (!child.isClass) "" // its a singleton enum value
           else {
             val s = child.whyNotGenericProduct
-            if (s.isEmpty) s
-            else if (child.is(Sealed)) {
-              val s = child.whyNotGenericSum(if child.useCompanionAsSumMirror then child.linkedClass else ctx.owner)
-              if (s.isEmpty) s
+            if s.isEmpty then s
+            else if child.is(Sealed) then
+              val s = child.whyNotGenericSum
+              if s.isEmpty then s
               else i"its child $child is not a generic sum because $s"
-            } else i"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.map(problem).find(!_.isEmpty).getOrElse("")
       }
 
-    def isGenericSum(declScope: Symbol)(using Context): Boolean = whyNotGenericSum(declScope).isEmpty
+    def isGenericSum(using Context): Boolean = whyNotGenericSum.isEmpty
 
     /** If this is a constructor, its owner: otherwise this. */
     final def skipConstructor(using Context): Symbol =

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

@@ -594,9 +594,9 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     if (clazz.is(Module)) {
       if (clazz.is(Case)) makeSingletonMirror()
       else if (linked.isGenericProduct) makeProductMirror(linked)
-      else if (linked.isGenericSum(clazz)) makeSumMirror(linked)
+      else if (linked.isGenericSum) makeSumMirror(linked)
       else if (linked.is(Sealed))
-        derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum(clazz)}")
+        derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum}")
     }
     else if (impl.removeAttachment(ExtendsSingletonMirror).isDefined)
       makeSingletonMirror()

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

@@ -26,7 +26,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
   /** Handlers to synthesize implicits for special types */
   type SpecialHandler = (Type, Span) => Context ?=> TreeWithErrors
   private type SpecialHandlers = List[(ClassSymbol, SpecialHandler)]
-  
+
   val synthesizedClassTag: SpecialHandler = (formal, span) =>
     formal.argInfos match
       case arg :: Nil =>
@@ -285,22 +285,6 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       case OrType(tp1, tp2) => acceptable(tp1, cls) && acceptable(tp2, cls)
       case _                => tp.classSymbol eq cls
 
-    /** for a case class, if it will have an anonymous mirror,
-     *  check that its constructor can be accessed
-     *  from the calling scope.
-     */
-    def canAccessCtor(cls: Symbol): Boolean =
-      !genAnonyousMirror(cls) || {
-        def isAccessible(sym: Symbol): Boolean = ctx.owner.isContainedIn(sym)
-        def isSub(sym: Symbol): Boolean = ctx.owner.ownersIterator.exists(_.derivesFrom(sym))
-        val ctor = cls.primaryConstructor
-        (!ctor.isOneOf(Private | Protected) || isSub(cls)) // we cant access the ctor because we do not extend cls
-        && (!ctor.privateWithin.exists || isAccessible(ctor.privateWithin)) // check scope is compatible
-      }
-
-    def genAnonyousMirror(cls: Symbol): Boolean =
-      cls.is(Scala2x) || cls.linkedClass.is(Case)
-
     def makeProductMirror(cls: Symbol): TreeWithErrors =
       val accessors = cls.caseAccessors.filterNot(_.isAllOf(PrivateLocal))
       val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
@@ -318,21 +302,11 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
           .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
           .refinedWith(tpnme.MirroredElemLabels, TypeAlias(elemsLabels))
       val mirrorRef =
-        if (genAnonyousMirror(cls)) anonymousMirror(monoType, ExtendsProductMirror, span)
-        else companionPath(mirroredType, span)
+        if cls.useCompanionAsProductMirror then companionPath(mirroredType, span)
+        else anonymousMirror(monoType, ExtendsProductMirror, span)
       withNoErrors(mirrorRef.cast(mirrorType))
     end makeProductMirror
 
-    def getError(cls: Symbol): String = 
-      val reason = if !cls.isGenericProduct then
-        i"because ${cls.whyNotGenericProduct}"
-      else if !canAccessCtor(cls) then
-        i"because the constructor of $cls is innaccessible from the calling scope."
-      else 
-        ""
-      i"$cls is not a generic product $reason"
-    end getError
-
     mirroredType match
       case AndType(tp1, tp2) =>
         orElse(productMirror(tp1, formal, span), productMirror(tp2, formal, span))
@@ -349,21 +323,19 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             withNoErrors(modulePath.cast(mirrorType))
         else
           val cls = mirroredType.classSymbol
-          if acceptable(mirroredType, cls)
-            && cls.isGenericProduct
-            && canAccessCtor(cls)
-          then
+          val clsIsGenericProduct = cls.isGenericProduct
+          if acceptable(mirroredType, cls) && clsIsGenericProduct then
             makeProductMirror(cls)
+          else if !clsIsGenericProduct then
+            (EmptyTree, List(i"$cls is not a generic product because ${cls.whyNotGenericProduct}"))
           else
-            (EmptyTree, List(getError(cls)))
+            EmptyTreeNoError
   end productMirror
 
   private def sumMirror(mirroredType: Type, formal: Type, span: Span)(using Context): TreeWithErrors =
 
     val cls = mirroredType.classSymbol
-    val useCompanion = cls.useCompanionAsSumMirror
-    val declScope = if useCompanion then cls.linkedClass else ctx.owner
-    val clsIsGenericSum = cls.isGenericSum(declScope)
+    val clsIsGenericSum = cls.isGenericSum
 
     def acceptable(tp: Type): Boolean = tp match
       case tp: TermRef => false
@@ -423,12 +395,12 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
             .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
       val mirrorRef =
-        if useCompanion then companionPath(mirroredType, span)
+        if cls.useCompanionAsSumMirror then companionPath(mirroredType, span)
         else anonymousMirror(monoType, ExtendsSumMirror, span)
       withNoErrors(mirrorRef.cast(mirrorType))
     else if !clsIsGenericSum then
-      (EmptyTree, List(i"$cls is not a generic sum because ${cls.whyNotGenericSum(declScope)}"))
-    else 
+      (EmptyTree, List(i"$cls is not a generic sum because ${cls.whyNotGenericSum}"))
+    else
       EmptyTreeNoError
   end sumMirror
 
@@ -595,7 +567,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             tp.baseType(cls)
         val base = baseWithRefinements(formal)
         val result =
-          if (base <:< formal.widenExpr)  
+          if (base <:< formal.widenExpr)
             // With the subtype test we enforce that the searched type `formal` is of the right form
             handler(base, span)
           else EmptyTreeNoError
@@ -609,19 +581,19 @@ end Synthesizer
 
 object Synthesizer:
 
-  /** Tuple used to store the synthesis result with a list of errors.  */ 
+  /** Tuple used to store the synthesis result with a list of errors.  */
   type TreeWithErrors = (Tree, List[String])
   private def withNoErrors(tree: Tree): TreeWithErrors = (tree, List.empty)
 
   private val EmptyTreeNoError: TreeWithErrors = withNoErrors(EmptyTree)
 
   private def orElse(treeWithErrors1: TreeWithErrors, treeWithErrors2: => TreeWithErrors): TreeWithErrors = treeWithErrors1 match
-    case (tree, errors) if tree eq genericEmptyTree => 
+    case (tree, errors) if tree eq genericEmptyTree =>
       val (tree2, errors2) = treeWithErrors2
       (tree2, errors ::: errors2)
     case _ => treeWithErrors1
 
-  private def clearErrorsIfNotEmpty(treeWithErrors: TreeWithErrors) = treeWithErrors match 
+  private def clearErrorsIfNotEmpty(treeWithErrors: TreeWithErrors) = treeWithErrors match
     case (tree, _) if tree eq genericEmptyTree => treeWithErrors
     case (tree, _)                             => withNoErrors(tree)
 

tests/neg/prod-mirror-inacessible-ctor.scala

@@ -0,0 +1,26 @@
+import scala.deriving.Mirror
+
+package lib {
+  sealed trait Foo
+  object Foo // normally, would cache a mirror if one exists.
+  case class Bar private[lib] () extends Foo
+  case object Bar // force mirror for Bar to be anonymous.
+
+
+  object CallSiteSucceed {
+    val mFoo = summon[Mirror.SumOf[lib.Foo]] // ok
+    val mBar = summon[Mirror.ProductOf[lib.Bar]] // ok
+  }
+
+}
+
+package app {
+
+  object MustFail {
+    // we are outsite of accessible scope for Bar's ctor, so this should fail.
+
+    val mFoo = summon[Mirror.SumOf[lib.Foo]] // error
+    val mBar = summon[Mirror.ProductOf[lib.Bar]] // error
+  }
+
+}

tests/run/prod-mirror-inacessible-ctor/Lib_1.scala

@@ -0,0 +1,15 @@
+package lib
+
+import scala.deriving.Mirror
+
+sealed trait Foo
+object Foo // normally, would cache a mirror if one exists.
+case class Bar private[lib] () extends Foo
+case object Bar // force mirror for Bar to be anonymous.
+
+
+object CallSiteSucceed {
+  val mFoo = summon[Mirror.SumOf[Foo]] // ok
+  val mBar = summon[Mirror.ProductOf[Bar]] // ok
+  val sampleBar = Bar()
+}

tests/run/prod-mirror-inacessible-ctor/Test_2.scala

@@ -0,0 +1,6 @@
+@main def Test =
+  assert(lib.CallSiteSucceed.mFoo eq lib.Foo) // binary compatibility with 3.1
+  assert(lib.CallSiteSucceed.mBar ne lib.Bar) // anonymous mirror
+
+  assert(lib.CallSiteSucceed.mFoo.ordinal(lib.CallSiteSucceed.sampleBar) == 0)
+  assert(lib.CallSiteSucceed.mBar.fromProduct(EmptyTuple) == lib.CallSiteSucceed.sampleBar)