Fix wrong owner when reading annotations.

This was the enclosing class instead of the method containing the annotation.
Fixing this is surprisingly hard.

Author: odersky

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

@@ -513,7 +513,7 @@ class TreeUnpickler(reader: TastyReader,
       val rhsStart = currentAddr
       val rhsIsEmpty = nothingButMods(end)
       if (!rhsIsEmpty) skipTree()
-      val (givenFlags, annots, privateWithin) = readModifiers(end, readAnnot, readWithin, NoSymbol)
+      val (givenFlags, annotFns, privateWithin) = readModifiers(end, readAnnot, readWithin, NoSymbol)
       pickling.println(i"creating symbol $name at $start with flags $givenFlags")
       val flags = normalizeFlags(tag, givenFlags, name, isAbsType, rhsIsEmpty)
       def adjustIfModule(completer: LazyType) =
@@ -532,13 +532,12 @@ class TreeUnpickler(reader: TastyReader,
             rootd.symbol
           case _ =>
             val completer = adjustIfModule(new Completer(ctx.owner, subReader(start, end)))
-
             if (isClass)
               ctx.newClassSymbol(ctx.owner, name.asTypeName, flags, completer, privateWithin, coord)
             else
               ctx.newSymbol(ctx.owner, name, flags, completer, privateWithin, coord)
         }
-      sym.annotations = annots
+      sym.annotations = annotFns.map(_(sym))
       ctx.owner match {
         case cls: ClassSymbol => cls.enter(sym)
         case _ =>
@@ -562,10 +561,10 @@ class TreeUnpickler(reader: TastyReader,
      *  boundary symbol.
      */
     def readModifiers[WithinType, AnnotType]
-        (end: Addr, readAnnot: Context => AnnotType, readWithin: Context => WithinType, defaultWithin: WithinType)
-        (implicit ctx: Context): (FlagSet, List[AnnotType], WithinType) = {
+        (end: Addr, readAnnot: Context => Symbol => AnnotType, readWithin: Context => WithinType, defaultWithin: WithinType)
+        (implicit ctx: Context): (FlagSet, List[Symbol => AnnotType], WithinType) = {
       var flags: FlagSet = EmptyFlags
-      var annots: List[AnnotType] = Nil
+      var annotFns: List[Symbol => AnnotType] = Nil
       var privateWithin = defaultWithin
       while (currentAddr.index != end.index) {
         def addFlag(flag: FlagSet) = {
@@ -617,29 +616,31 @@ class TreeUnpickler(reader: TastyReader,
             addFlag(Protected)
             privateWithin = readWithin(ctx)
           case ANNOTATION =>
-            annots = readAnnot(ctx) :: annots
+            annotFns = readAnnot(ctx) :: annotFns
           case tag =>
             assert(false, s"illegal modifier tag $tag at $currentAddr, end = $end")
         }
       }
-      (flags, annots.reverse, privateWithin)
+      (flags, annotFns.reverse, privateWithin)
     }
 
     private val readWithin: Context => Symbol =
       implicit ctx => readType().typeSymbol
 
-    private val readAnnot: Context => Annotation = {
+    private val readAnnot: Context => Symbol => Annotation = {
       implicit ctx =>
         readByte()
         val end = readEnd()
         val tp = readType()
-        val lazyAnnotTree = readLater(end, rdr => ctx => rdr.readTerm()(ctx))
-        if (tp.isRef(defn.BodyAnnot))
-          LazyBodyAnnotation(implicit ctx => lazyAnnotTree.complete)
-        else
-          Annotation.deferredSymAndTree(
-            implicit ctx => tp.typeSymbol,
-            implicit ctx => lazyAnnotTree.complete)
+        val lazyAnnotTree = readLaterWithOwner(end, rdr => ctx => rdr.readTerm()(ctx))
+
+        owner =>
+          if (tp.isRef(defn.BodyAnnot))
+            LazyBodyAnnotation(implicit ctx => lazyAnnotTree(owner).complete)
+          else
+            Annotation.deferredSymAndTree(
+              implicit ctx => tp.typeSymbol,
+              implicit ctx => lazyAnnotTree(owner).complete)
     }
 
     /** Create symbols for the definitions in the statement sequence between
@@ -1165,10 +1166,13 @@ class TreeUnpickler(reader: TastyReader,
       setPos(start, CaseDef(pat, guard, rhs))
     }
 
-    def readLater[T <: AnyRef](end: Addr, op: TreeReader => Context => T)(implicit ctx: Context): Trees.Lazy[T] = {
+    def readLater[T <: AnyRef](end: Addr, op: TreeReader => Context => T)(implicit ctx: Context): Trees.Lazy[T] =
+      readLaterWithOwner(end, op)(ctx)(ctx.owner)
+
+    def readLaterWithOwner[T <: AnyRef](end: Addr, op: TreeReader => Context => T)(implicit ctx: Context): Symbol => Trees.Lazy[T] = {
       val localReader = fork
       goto(end)
-      new LazyReader(localReader, ctx.owner, ctx.mode, op)
+      owner => new LazyReader(localReader, owner, ctx.mode, op)
     }
 
     def readHole(end: Addr, isType: Boolean)(implicit ctx: Context): Tree = {
@@ -1265,7 +1269,7 @@ class TreeUnpickler(reader: TastyReader,
         def readMods(): untpd.Modifiers = {
           val (flags, annots, privateWithin) =
             readModifiers(end, readUntypedAnnot, readUntypedWithin, EmptyTypeName)
-          untpd.Modifiers(flags, privateWithin, annots)
+          untpd.Modifiers(flags, privateWithin, annots.map(_(NoSymbol)))
         }
 
         def readRhs(): untpd.Tree =
@@ -1384,8 +1388,8 @@ class TreeUnpickler(reader: TastyReader,
     private val readUntypedWithin: Context => TypeName =
       implicit ctx => readName().toTypeName
 
-    private val readUntypedAnnot: Context => untpd.Tree =
-      implicit ctx => readUntyped()
+    private val readUntypedAnnot: Context => Symbol => untpd.Tree =
+      implicit ctx => _ => readUntyped()
 
 // ------ Setting positions ------------------------------------------------