Fix inaccessibility criterion

It turns out we have to know a priori whether we should
register a local class as a child and we need to be precise
about it.

Author: odersky

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -570,12 +570,11 @@ class TreePickler(pickler: TastyPickler) {
       if (flags is Covariant) writeByte(COVARIANT)
       if (flags is Contravariant) writeByte(CONTRAVARIANT)
     }
-    sym.annotations.foreach(pickleAnnotation)
+    sym.annotations.foreach(pickleAnnotation(sym, _))
   }
 
-  private def isUnpicklable(ann: Annotation)(implicit ctx: Context) = ann match {
-    case Annotation.Child(sym) =>
-      sym.isLocal && ctx.owner.topLevelClass != sym.topLevelClass
+  private def isUnpicklable(owner: Symbol, ann: Annotation)(implicit ctx: Context) = ann match {
+    case Annotation.Child(sym) => sym.isInaccessibleChildOf(owner)
       // If child annotation refers to a local class or enum value under
       // a different toplevel class, it is impossible to pickle a reference to it.
       // Such annotations will be reconstituted when unpickling the child class.
@@ -584,8 +583,8 @@ class TreePickler(pickler: TastyPickler) {
       // inline bodies are reconstituted automatically when unpickling
   }
 
-  def pickleAnnotation(ann: Annotation)(implicit ctx: Context) =
-    if (!isUnpicklable(ann)) {
+  def pickleAnnotation(owner: Symbol, ann: Annotation)(implicit ctx: Context) =
+    if (!isUnpicklable(owner, ann)) {
       writeByte(ANNOTATION)
       withLength { pickleType(ann.symbol.typeRef); pickleTree(ann.tree) }
     }

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -705,7 +705,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
       if ((sym.isClass || sym.is(CaseVal)) && sym.isLocal)
         // Child annotations for local classes and enum values are not pickled, so
         // need to be re-established here.
-        sym.registerIfChild()
+        sym.registerIfChild(late = true)
       tree
     }
 

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

@@ -137,11 +137,13 @@ class SymUtils(val self: Symbol) extends AnyVal {
 
   /** If this symbol is an enum value or a named class, register it as a child
    *  in all direct parent classes which are sealed.
+   *   @param  @late  If true, register only inaccessible children (all others are already
+   *                  entered at this point).
    */
-  def registerIfChild()(implicit ctx: Context): Unit = {
+  def registerIfChild(late: Boolean = false)(implicit ctx: Context): Unit = {
     def register(child: Symbol, parent: Type) = {
       val cls = parent.classSymbol
-      if (cls.is(Sealed) && !cls.children.contains(child))
+      if (cls.is(Sealed) && (!late || child.isInaccessibleChildOf(cls)))
         cls.addAnnotation(Annotation.Child(child))
     }
     if (self.isClass && !self.isAnonymousClass)
@@ -153,6 +155,13 @@ class SymUtils(val self: Symbol) extends AnyVal {
       register(self, self.info)
   }
 
+  /** Is this symbol defined locally (i.e. at some level owned by a term) and
+   *  defined in a different toplevel class than its supposed parent class `cls`?
+   *  Such children are not pickled, and have to be reconstituted manually.
+   */
+  def isInaccessibleChildOf(cls: Symbol)(implicit ctx: Context) =
+    self.isLocal && !cls.topLevelClass.isLinkedWith(self.topLevelClass)
+
   /** If this is a sealed class, its known children */
   def children(implicit ctx: Context): List[Symbol] =
     self.annotations.collect {