Tighten check to cache Mirror.Sum in companion

cache the mirror in the companion if:
- the class is not scala 2 defined
  & the class has a companion
  & the class was either:
    - defined in source
    - its companion is a subtype of Mirror.Sum

Author: bishabosha

compiler/src/dotty/tools/dotc/Run.scala

@@ -194,6 +194,9 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   /** The source files of all late entered symbols, as a set */
   private var lateFiles = mutable.Set[AbstractFile]()
 
+  def isLateEntered(source: AbstractFile): Boolean =
+    lateFiles(source)
+
   /** A cache for static references to packages and classes */
   val staticRefs = util.EqHashMap[Name, Denotation](initialCapacity = 1024)
 

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

@@ -146,6 +146,17 @@ object Symbols {
           false
       }
 
+    /** Does this symbol come from a currently compiled source file? (with addition of symbols from the sourcepath) */
+    final def isFromSourceInCurrentRun(using Context): Boolean =
+      span.exists && defRunId == ctx.runId && {
+        try
+          val file = associatedFile
+          file != null && ctx.run.files.contains(file) || ctx.run.isLateEntered(file)
+        catch case ex: StaleSymbol =>
+          // can happen for constructor proxy companions. Test case is pos-macros/i9484.
+          false
+      }
+
     /** Is symbol valid in current run? */
     final def isValidInCurrentRun(using Context): Boolean =
       (lastDenot.validFor.runId == ctx.runId || stillValid(lastDenot)) &&

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

@@ -112,7 +112,14 @@ object SymUtils:
           self.isCoDefinedGiven(res.typeSymbol)
       self.isAllOf(Given | Method) && isCodefined(self.info)
 
-    def useCompanionAsMirror(using Context): Boolean = self.linkedClass.exists && !self.is(Scala2x)
+    def useCompanionAsSumMirror(using Context): Boolean =
+      self.linkedClass.exists
+      && !self.is(Scala2x)
+      && (
+        // self is from source, or companion is a subtype of Sum
+        self.isFromSourceInCurrentRun
+        || self.linkedClass.isSubClass(defn.Mirror_SumClass)
+      )
 
     /** Is this a sealed class or trait for which a sum mirror is generated?
     *  It must satisfy the following conditions:
@@ -129,7 +136,7 @@ object SymUtils:
         s"it is not an abstract class"
       else {
         val children = self.children
-        val companionMirror = self.useCompanionAsMirror
+        val companionMirror = self.useCompanionAsSumMirror
         assert(!(companionMirror && (declScope ne self.linkedClass)))
         def problem(child: Symbol) = {
 
@@ -144,7 +151,7 @@ object SymUtils:
             val s = child.whyNotGenericProduct
             if (s.isEmpty) s
             else if (child.is(Sealed)) {
-              val s = child.whyNotGenericSum(if child.useCompanionAsMirror then child.linkedClass else ctx.owner)
+              val s = child.whyNotGenericSum(if child.useCompanionAsSumMirror then child.linkedClass else ctx.owner)
               if (s.isEmpty) 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"

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

@@ -271,7 +271,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
   private def sumMirror(mirroredType: Type, formal: Type, span: Span)(using Context): Tree =
     val cls = mirroredType.classSymbol
-    val useCompanion = cls.useCompanionAsMirror
+    val useCompanion = cls.useCompanionAsSumMirror
 
     if cls.isGenericSum(if useCompanion then cls.linkedClass else ctx.owner) then
       val elemLabels = cls.children.map(c => ConstantType(Constant(c.name.toString)))