remove prefix splice in companionref

Author: bishabosha

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

@@ -874,6 +874,10 @@ object TypeOps:
           if term.widen.classSymbol eq cls then Some(pre)
           else loopThisType(cls, term.prefix)
 
+        case supTpe: SuperType =>
+          if supTpe.thistpe.classSymbol.isSubClass(cls) then Some(pre)
+          else None
+
         case _ => None
 
     end PrefixSplice

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

@@ -92,6 +92,11 @@ object TypeUtils {
         val r2 = tp2.mirrorCompanionRef
         assert(r1.symbol == r2.symbol, em"mirrorCompanionRef mismatch for $self: $r1, $r2 did not have the same symbol")
         r1
+      case AndType(tp1, tp2) =>
+        val c1 = tp1.classSymbol
+        val c2 = tp2.classSymbol
+        if c1.isSubClass(c2) then tp1.mirrorCompanionRef
+        else tp2.mirrorCompanionRef // precondition: the parts of the AndType have already been checked to be non-overlapping
       case self @ TypeRef(prefix, _) if self.symbol.isClass =>
         prefix.select(self.symbol.companionModule).asInstanceOf[TermRef]
       case self: TypeProxy =>

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

@@ -250,11 +250,8 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       .refinedWith(tpnme.MirroredLabel, TypeAlias(ConstantType(Constant(label.toString))))
 
   /** A path referencing the companion of class type `clsType` */
-  private def companionPath(mirroredType: Type, cls: Symbol, pre: Type, span: Span)(using Context) =
-    val clsType =
-      // ok to assume healPrefix will succeed because `cls` and `pre` derive from the same type.
-      // TODO: will fail, e.g. for value alias to case object - we still need to support `scala.package.None.type`
-      TypeOps.healPrefix(mirroredType.mirrorCompanionRef, pre).toOption.get
+  private def companionPath(mirroredType: Type, cls: Symbol, span: Span)(using Context) =
+    val clsType = mirroredType.mirrorCompanionRef
     val ref = pathFor(clsType)
     assert(ref.symbol.is(Module) && (cls.is(ModuleClass) || (ref.symbol.companionClass == cls)))
     ref.withSpan(span)
@@ -328,7 +325,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         if (genAnonyousMirror(cls))
           // TODO: scan for problematic prefix
           anonymousMirror(monoType, mirroredType, ExtendsProductMirror, pre, span)
-        else companionPath(mirroredType, cls, pre, span)
+        else companionPath(mirroredType, cls, span)
       withNoErrors(mirrorRef.cast(mirrorType))
     end makeProductMirror
 
@@ -342,10 +339,6 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       i"$cls is not a generic product $reason"
     end getError
 
-    if pre == NoPrefix then
-      report.error(i"$mirroredType is not a valid prod type, because it does not have a prefix")
-    else
-      report.warning(i"prod mirror with $mirroredType: pre $pre")
     mirroredType match
       case AndType(tp1, tp2) =>
         orElse(productMirror(tp1, formal, span), productMirror(tp2, formal, span))
@@ -375,10 +368,6 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
     val pre = TypeOps.extractPrefix(mirroredType) match
       case pre if pre.exists => pre
       case _                 => return EmptyTreeNoError
-    // if pre == NoPrefix then
-    //   report.error(i"$mirroredType is not a valid sum type, because it does not have a prefix")
-    // else
-    //   report.warning(i"sum mirror with $mirroredType: pre $pre")
     val cls = mirroredType.classSymbol
     val useCompanion = cls.useCompanionAsSumMirror
     val declScope = if useCompanion then cls.linkedClass else ctx.owner
@@ -456,7 +445,7 @@ 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, cls, pre, span)
+          if useCompanion then companionPath(mirroredType, cls, span)
           else anonymousMirror(monoType, mirroredType, ExtendsSumMirror, pre, span)
         withNoErrors(mirrorRef.cast(mirrorType))
     else if !cls.isGenericSum(pre, if useCompanion then cls.linkedClass else ctx.owner) then

tests/run/anon-mirror-gen-dep-i.scala

@@ -9,7 +9,7 @@ class Outer {
     case class Seed() extends Item
   }
 
-  lazy val o = new Outer() // infinite init
+  final lazy val o = new Outer() // infinite init
 
   def hello: Unit = {
 

tests/run/anon-mirror-gen-dep-j.scala

@@ -0,0 +1,27 @@
+import scala.deriving.Mirror
+import scala.CanEqual.derived
+
+class Outer {
+
+  sealed trait Item
+  case class Fruit(seed: Seed) extends Item
+  case class Seed() extends Item
+
+  final lazy val o = new Outer() // infinite init
+
+  def hello: Unit = {
+
+    val mFruit = summon[Mirror.Of[o.Item & o.Fruit]]
+    type derivedSeed = Tuple.Head[mFruit.MirroredElemTypes]
+    val mSeed = summon[Mirror.Of[derivedSeed]]
+
+    assert(mFruit.fromProduct(Tuple(o.Seed())) == o.Fruit(o.Seed()))
+    assert(mSeed.fromProduct(EmptyTuple) == o.Seed()) // careful to ensure that correct outer is captured
+  }
+
+}
+
+@main def Test = {
+  val o = new Outer()
+  o.hello
+}

tests/neg/anon-mirror-gen-super-a.scala renamed to tests/run/anon-mirror-gen-super-a.scala

@@ -8,7 +8,8 @@ import scala.deriving.Mirror
   }
 
   class Bar extends Foo {
-    summon[Mirror.Of[Bar.super.foo.type]] //
+    val mQux = summon[Mirror.Of[Bar.super.foo.type]]
+    assert(mQux.fromProduct(EmptyTuple) == Qux)
   }
 
 }