Fix #1647 Evaluate annotation arguments in proper context

Need to evaluate annotation arguments in an expression context, since
classes defined in asuch arguments should not be entered into enclosing
class.

Fixes #1647

Author: odersky

src/dotty/tools/dotc/core/Contexts.scala

@@ -422,6 +422,13 @@ object Contexts {
     final def withOwner(owner: Symbol): Context =
       if (owner ne this.owner) fresh.setOwner(owner) else this
 
+    final def withProperty[T](key: Key[T], value: Option[T]): Context =
+      if (property(key) == value) this
+      else value match {
+        case Some(v) => fresh.setProperty(key, v)
+        case None => fresh.dropProperty(key)
+      }
+
     override def toString = {
       def iinfo(implicit ctx: Context) = if (ctx.importInfo == null) "" else i"${ctx.importInfo.selectors}%, %"
       "Context(\n" +
@@ -470,6 +477,9 @@ object Contexts {
     def setProperty[T](key: Key[T], value: T): this.type =
       setMoreProperties(moreProperties.updated(key, value))
 
+    def dropProperty(key: Key[_]): this.type =
+      setMoreProperties(moreProperties - key)
+
     def setPhase(pid: PhaseId): this.type = setPeriod(Period(runId, pid))
     def setPhase(phase: Phase): this.type = setPeriod(Period(runId, phase.start, phase.end))
 

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

@@ -27,7 +27,7 @@ import EtaExpansion.etaExpand
 import dotty.tools.dotc.transform.Erasure.Boxing
 import util.Positions._
 import util.common._
-import util.SourcePosition
+import util.{SourcePosition, Property}
 import collection.mutable
 import annotation.tailrec
 import Implicits._
@@ -57,6 +57,8 @@ object Typer {
   def assertPositioned(tree: untpd.Tree)(implicit ctx: Context) =
     if (!tree.isEmpty && !tree.isInstanceOf[untpd.TypedSplice] && ctx.typerState.isGlobalCommittable)
       assert(tree.pos.exists, s"position not set for $tree # ${tree.uniqueId}")
+
+  private val ExprOwner = new Property.Key[Symbol]
 }
 
 class Typer extends Namer with TypeAssigner with Applications with Implicits with Dynamic with Checking with Docstrings {
@@ -1135,7 +1137,13 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   def completeAnnotations(mdef: untpd.MemberDef, sym: Symbol)(implicit ctx: Context): Unit = {
     // necessary to force annotation trees to be computed.
     sym.annotations.foreach(_.ensureCompleted)
-    val annotCtx = ctx.outersIterator.dropWhile(_.owner == sym).next
+    lazy val annotCtx = {
+      val c = ctx.outersIterator.dropWhile(_.owner == sym).next
+      c.property(ExprOwner) match {
+        case Some(exprOwner) if c.owner.isClass => c.exprContext(mdef, exprOwner)
+        case None => c
+      }
+    }
     // necessary in order to mark the typed ahead annotations as definitely typed:
     untpd.modsDeco(mdef).mods.annotations.foreach(typedAnnotation(_)(annotCtx))
   }
@@ -1541,7 +1549,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case nil =>
         buf.toList
     }
-    traverse(stats)
+    val localCtx = {
+      val exprOwnerOpt = if (exprOwner == ctx.owner) None else Some(exprOwner)
+      ctx.withProperty(ExprOwner, exprOwnerOpt)
+    }
+    traverse(stats)(localCtx)
   }
 
   /** Given an inline method `mdef`, the method rewritten so that its body

tests/neg/i1647.scala

@@ -0,0 +1,4 @@
+class ann {
+  @ann({ def baz })  // error: missing return type
+  def foo(): Unit
+}