Make sure annotations are typed in expression contexts

The previous logic tried but had holes. A local context was
established in `typedStats#localCtx` but that context was not
found in annotations that were typechecked in the completer
of the definition they decorated.

We are now more through and always allocate a localDummy as
new owner if the owner would otherwise we a class. This means
that closures in annotation arguments will have a term as owner,
and therefore will be allocated in distinct local scopes.

Fixes #15054

Author: odersky

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

@@ -625,7 +625,9 @@ class TreeUnpickler(reader: TastyReader,
             else
               newSymbol(ctx.owner, name, flags, completer, privateWithin, coord)
         }
-      val annots = annotFns.map(_(sym.owner))
+      val annotOwner =
+        if sym.owner.isClass then newLocalDummy(sym.owner) else sym.owner
+      val annots = annotFns.map(_(annotOwner))
       sym.annotations = annots
       if sym.isOpaqueAlias then sym.setFlag(Deferred)
       val isScala2MacroDefinedInScala3 = flags.is(Macro, butNot = Inline) && flags.is(Erased)

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

@@ -2238,25 +2238,23 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *  since classes defined in a such arguments should not be entered into the
    *  enclosing class.
    */
-  def annotContext(mdef: untpd.Tree, sym: Symbol)(using Context): Context = {
+  def annotContext(mdef: untpd.Tree, sym: Symbol)(using Context): Context =
     def isInner(owner: Symbol) = owner == sym || sym.is(Param) && owner == sym.owner
     val outer = ctx.outersIterator.dropWhile(c => isInner(c.owner)).next()
-    var adjusted = outer.property(ExprOwner) match {
+    val adjusted = outer.property(ExprOwner) match {
       case Some(exprOwner) if outer.owner.isClass => outer.exprContext(mdef, exprOwner)
       case _ => outer
     }
+    def local: FreshContext = adjusted.fresh.setOwner(newLocalDummy(sym.owner))
     sym.owner.infoOrCompleter match
-      case completer: Namer#Completer if sym.is(Param) =>
-        val tparams = completer.completerTypeParams(sym)
-        if tparams.nonEmpty then
-          // Create a new local context with a dummy owner and a scope containing the
-          // type parameters of the enclosing method or class. Thus annotations can see
-          // these type parameters. See i12953.scala for a test case.
-          val dummyOwner = newLocalDummy(sym.owner)
-          adjusted = adjusted.fresh.setOwner(dummyOwner).setScope(newScopeWith(tparams*))
+      case completer: Namer#Completer
+      if sym.is(Param) && completer.completerTypeParams(sym).nonEmpty =>
+        // Create a new local context with a dummy owner and a scope containing the
+        // type parameters of the enclosing method or class. Thus annotations can see
+        // these type parameters. See i12953.scala for a test case.
+        local.setScope(newScopeWith(completer.completerTypeParams(sym)*))
       case _ =>
-    adjusted
-  }
+        if outer.owner.isClass then local else adjusted
 
   def completeAnnotations(mdef: untpd.MemberDef, sym: Symbol)(using Context): Unit = {
     // necessary to force annotation trees to be computed.

tests/pos/i15054.scala

@@ -0,0 +1,15 @@
+import scala.annotation.Annotation
+
+class AnAnnotation(function: Int => String) extends Annotation
+
+@AnAnnotation(_.toString)
+val a = 1
+@AnAnnotation(_.toString.length.toString)
+val b = 2
+
+def test =
+  @AnAnnotation(_.toString)
+  val a = 1
+  @AnAnnotation(_.toString.length.toString)
+  val b = 2
+  a + b