Merge pull request #1302 from scalamacros/topic/reflection

cleaning up reflection

42 files changed, 252 insertions, 280 deletions

diff --git a/src/compiler/scala/reflect/macros/runtime/Evals.scala b/src/compiler/scala/reflect/macros/runtime/Evals.scala
index 348e29cdd7..acafeb5b02 100644
--- a/src/compiler/scala/reflect/macros/runtime/Evals.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Evals.scala
@@ -13,6 +13,6 @@ trait Evals {
 
   def eval[T](expr: Expr[T]): T = {
     val imported = evalImporter.importTree(expr.tree)
-    evalToolBox.runExpr(imported).asInstanceOf[T]
+    evalToolBox.eval(imported).asInstanceOf[T]
   }
 }
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala b/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala
index 77ac8c6581..a8cc61e0f9 100644
--- a/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala
@@ -33,8 +33,4 @@ trait Infrastructure {
   }
 
   val currentMacro: Symbol = expandee.symbol
-
-  val globalCache: scala.collection.mutable.Map[Any, Any] = universe.analyzer.globalMacroCache
-
-  val cache: scala.collection.mutable.Map[Any, Any] = universe.analyzer.perRunMacroCache.getOrElseUpdate(currentMacro, collection.mutable.Map[Any, Any]())
 }
diff --git a/src/compiler/scala/reflect/macros/runtime/Parsers.scala b/src/compiler/scala/reflect/macros/runtime/Parsers.scala
index e4acf104e3..5096526fdb 100644
--- a/src/compiler/scala/reflect/macros/runtime/Parsers.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Parsers.scala
@@ -12,7 +12,7 @@ trait Parsers {
     // todo. provide decent implementation
     try {
       import scala.reflect.runtime.{universe => ru}
-      val parsed = ru.rootMirror.mkToolBox().parseExpr(code)
+      val parsed = ru.rootMirror.mkToolBox().parse(code)
       val importer = universe.mkImporter(ru)
       importer.importTree(parsed)
     } catch {
diff --git a/src/compiler/scala/reflect/reify/codegen/GenAnnotationInfos.scala b/src/compiler/scala/reflect/reify/codegen/GenAnnotationInfos.scala
index 5f4296f54f..dec491aabe 100644
--- a/src/compiler/scala/reflect/reify/codegen/GenAnnotationInfos.scala
+++ b/src/compiler/scala/reflect/reify/codegen/GenAnnotationInfos.scala
@@ -50,6 +50,6 @@ trait GenAnnotationInfos {
 
     // if you reify originals of anns, you get SO when trying to reify AnnotatedTypes, so screw it - after all, it's not that important
     val reifiedAssocs = ann.assocs map (assoc => scalaFactoryCall(nme.Tuple2, reify(assoc._1), reifyClassfileAnnotArg(assoc._2)))
-    mirrorFactoryCall(nme.AnnotationInfo, reify(ann.atp), mkList(reifiedArgs), mkList(reifiedAssocs))
+    mirrorFactoryCall(nme.Annotation, reify(ann.atp), mkList(reifiedArgs), mkListMap(reifiedAssocs))
   }
 }
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/reify/codegen/GenSymbols.scala b/src/compiler/scala/reflect/reify/codegen/GenSymbols.scala
index c4b674955a..22a834d2e4 100644
--- a/src/compiler/scala/reflect/reify/codegen/GenSymbols.scala
+++ b/src/compiler/scala/reflect/reify/codegen/GenSymbols.scala
@@ -143,7 +143,7 @@ trait GenSymbols {
       //    produces valid Scala code (with vals in a block depending only on lexically preceding vals)
       val reification = reificode(sym)
       import reification.{name, binding}
-      val tree = reification.tree addAttachment ReifyBindingAttachment(binding)
+      val tree = reification.tree updateAttachment ReifyBindingAttachment(binding)
       state.symtab += (sym, name, tree)
     }
     fromSymtab
diff --git a/src/compiler/scala/reflect/reify/codegen/GenUtils.scala b/src/compiler/scala/reflect/reify/codegen/GenUtils.scala
index 8aef8d772f..49877b4286 100644
--- a/src/compiler/scala/reflect/reify/codegen/GenUtils.scala
+++ b/src/compiler/scala/reflect/reify/codegen/GenUtils.scala
@@ -70,6 +70,9 @@ trait GenUtils {
   def mkList(args: List[Tree]): Tree =
     scalaFactoryCall("collection.immutable.List", args: _*)
 
+  def mkListMap(args: List[Tree]): Tree =
+    scalaFactoryCall("collection.immutable.ListMap", args: _*)
+
   /**
    * An (unreified) path that refers to definition with given fully qualified name
    *  @param mkName   Creator for last portion of name (either TermName or TypeName)
diff --git a/src/compiler/scala/reflect/reify/utils/NodePrinters.scala b/src/compiler/scala/reflect/reify/utils/NodePrinters.scala
index ec1f132c1b..c023be1a50 100644
--- a/src/compiler/scala/reflect/reify/utils/NodePrinters.scala
+++ b/src/compiler/scala/reflect/reify/utils/NodePrinters.scala
@@ -94,7 +94,7 @@ trait NodePrinters {
       if (isExpr) {
         if (mirror contains ".getClassLoader") {
           printout += "import scala.tools.reflect.ToolBox"
-          printout += s"println(${nme.MIRROR_SHORT}.mkToolBox().runExpr(tree))"
+          printout += s"println(${nme.MIRROR_SHORT}.mkToolBox().eval(tree))"
         } else {
           printout += "println(tree)"
         }
diff --git a/src/compiler/scala/reflect/reify/utils/SymbolTables.scala b/src/compiler/scala/reflect/reify/utils/SymbolTables.scala
index 2e17558f54..3ec43c863d 100644
--- a/src/compiler/scala/reflect/reify/utils/SymbolTables.scala
+++ b/src/compiler/scala/reflect/reify/utils/SymbolTables.scala
@@ -46,8 +46,8 @@ trait SymbolTables {
 
     def symRef(sym: Symbol): Tree =
       symtab.get(sym) match {
-        case Some(FreeDef(_, name, binding, _, _)) => Ident(name) addAttachment binding
-        case Some(SymDef(_, name, _, _)) => Ident(name) addAttachment ReifyBindingAttachment(Ident(sym))
+        case Some(FreeDef(_, name, binding, _, _)) => Ident(name) updateAttachment binding
+        case Some(SymDef(_, name, _, _)) => Ident(name) updateAttachment ReifyBindingAttachment(Ident(sym))
         case None => EmptyTree
       }
 
@@ -86,7 +86,7 @@ trait SymbolTables {
         newTermName(fresh.newName(name))
       }
       val bindingAttachment = reification.attachments.get[ReifyBindingAttachment].get
-      add(ValDef(NoMods, freshName(name0), TypeTree(), reification) addAttachment bindingAttachment)
+      add(ValDef(NoMods, freshName(name0), TypeTree(), reification) updateAttachment bindingAttachment)
     }
 
     private def add(sym: Symbol, name: TermName): SymbolTable = {
@@ -203,7 +203,7 @@ trait SymbolTables {
             result ++= cumulativeAliases.distinct filter (alias => alias._1 == sym && alias._2 != currtab.symName(sym)) map (alias => {
               val canonicalName = currtab.symName(sym)
               val aliasName = alias._2
-              ValDef(NoMods, aliasName, TypeTree(), Ident(canonicalName)) addAttachment ReifyAliasAttachment(sym, aliasName)
+              ValDef(NoMods, aliasName, TypeTree(), Ident(canonicalName)) updateAttachment ReifyAliasAttachment(sym, aliasName)
             })
           result.toList
         })
diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala
index 4e643e6f32..ea1b26469b 100644
--- a/src/compiler/scala/tools/nsc/ast/Trees.scala
+++ b/src/compiler/scala/tools/nsc/ast/Trees.scala
@@ -178,7 +178,7 @@ trait Trees extends scala.reflect.internal.Trees { self: Global =>
     case _ => super.xtraverse(traverser, tree)
   }
 
-  trait TreeCopier extends super.TreeCopierOps {
+  trait TreeCopier extends super.InternalTreeCopierOps {
     def DocDef(tree: Tree, comment: DocComment, definition: Tree): DocDef
     def SelectFromArray(tree: Tree, qualifier: Tree, selector: Name, erasure: Type): SelectFromArray
     def InjectDerivedValue(tree: Tree, arg: Tree): InjectDerivedValue
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index c925669444..e3755b82d5 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -1029,7 +1029,7 @@ self =>
         val tok = in.token
         val name = ident()
         t = atPos(start) {
-          if (tok == BACKQUOTED_IDENT) Ident(name) addAttachment BackquotedIdentifierAttachment
+          if (tok == BACKQUOTED_IDENT) Ident(name) updateAttachment BackquotedIdentifierAttachment
           else Ident(name)
         }
         if (in.token == DOT) {
diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
index 002cf0c5e8..a987da8ba6 100644
--- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
@@ -894,9 +894,9 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
   }
 
   /** */
-  def makeAnnotation(annot: AnnotationInfo): Annotation = {
+  def makeAnnotation(annot: AnnotationInfo): scala.tools.nsc.doc.model.Annotation = {
     val aSym = annot.symbol
-    new EntityImpl(aSym, makeTemplate(aSym.owner)) with Annotation {
+    new EntityImpl(aSym, makeTemplate(aSym.owner)) with scala.tools.nsc.doc.model.Annotation {
       lazy val annotationClass =
         makeTemplate(annot.symbol)
       val arguments = { // lazy
diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index 7dafc9b467..b3b0c82d38 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -1082,7 +1082,7 @@ abstract class Erasure extends AddInterfaces
                 // println("inject derived: "+arg+" "+tpt.tpe)
                 val List(arg) = args
                 val attachment = new TypeRefAttachment(tree.tpe.asInstanceOf[TypeRef])
-                InjectDerivedValue(arg) addAttachment attachment
+                InjectDerivedValue(arg) updateAttachment attachment
               case _ =>
                 preEraseNormalApply(tree)
             }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 7e9b288853..d3580c19ef 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -49,9 +49,6 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
   import MacrosStats._
   def globalSettings = global.settings
 
-  val globalMacroCache = collection.mutable.Map[Any, Any]()
-  val perRunMacroCache = perRunCaches.newMap[Symbol, collection.mutable.Map[Any, Any]]
-
   /** `MacroImplBinding` and its companion module are responsible for
    *  serialization/deserialization of macro def -> impl bindings.
    *
@@ -713,7 +710,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
             if (isNullaryInvocation(expandee)) expectedTpe = expectedTpe.finalResultType
             var typechecked = typecheck("macro def return type", expanded, expectedTpe)
             typechecked = typecheck("expected type", typechecked, pt)
-            typechecked addAttachment MacroExpansionAttachment(expandee)
+            typechecked updateAttachment MacroExpansionAttachment(expandee)
           } finally {
             popMacroContext()
           }
@@ -762,7 +759,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
       case (false, true) =>
         macroLogLite("macro expansion is delayed: %s".format(expandee))
         delayed += expandee -> undetparams
-        expandee addAttachment MacroRuntimeAttachment(delayed = true, typerContext = typer.context, macroContext = Some(macroArgs(typer, expandee).c))
+        expandee updateAttachment MacroRuntimeAttachment(delayed = true, typerContext = typer.context, macroContext = Some(macroArgs(typer, expandee).c))
         Delay(expandee)
       case (false, false) =>
         import typer.TyperErrorGen._
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 161df00220..9e66d696cb 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -637,7 +637,7 @@ trait Namers extends MethodSynthesis {
           MaxParametersCaseClassError(tree)
 
         val m = ensureCompanionObject(tree, caseModuleDef)
-        m.moduleClass.addAttachment(new ClassForCaseCompanionAttachment(tree))
+        m.moduleClass.updateAttachment(new ClassForCaseCompanionAttachment(tree))
       }
       val hasDefault = impl.body exists {
         case DefDef(_, nme.CONSTRUCTOR, _, vparamss, _, _)  => mexists(vparamss)(_.mods.hasDefault)
@@ -645,7 +645,7 @@ trait Namers extends MethodSynthesis {
       }
       if (hasDefault) {
         val m = ensureCompanionObject(tree)
-        m.addAttachment(new ConstructorDefaultsAttachment(tree, null))
+        m.updateAttachment(new ConstructorDefaultsAttachment(tree, null))
       }
       val owner = tree.symbol.owner
       if (settings.lint.value && owner.isPackageObjectClass && !mods.isImplicit) {
@@ -1172,7 +1172,7 @@ trait Namers extends MethodSynthesis {
               // symbol will be re-entered in the scope but the default parameter will not.
               val att = meth.attachments.get[DefaultsOfLocalMethodAttachment] match {
                 case Some(att) => att.defaultGetters += default
-                case None => meth.addAttachment(new DefaultsOfLocalMethodAttachment(default))
+                case None => meth.updateAttachment(new DefaultsOfLocalMethodAttachment(default))
               }
             }
           } else if (baseHasDefault) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 8a3c509e81..5200aae8d1 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -2482,7 +2482,7 @@ trait Typers extends Modes with Adaptations with Tags {
           match_ setType B1.tpe
 
           // the default uses applyOrElse's first parameter since the scrut's type has been widened
-          val body = methodBodyTyper.virtualizedMatch(match_ addAttachment DefaultOverrideMatchAttachment(REF(default) APPLY (REF(x))), mode, B1.tpe)
+          val body = methodBodyTyper.virtualizedMatch(match_ updateAttachment DefaultOverrideMatchAttachment(REF(default) APPLY (REF(x))), mode, B1.tpe)
 
           DefDef(methodSym, body)
         }
@@ -2500,7 +2500,7 @@ trait Typers extends Modes with Adaptations with Tags {
           methodSym setInfoAndEnter MethodType(paramSyms, BooleanClass.tpe)
 
           val match_ = methodBodyTyper.typedMatch(gen.mkUnchecked(selector), casesTrue, mode, BooleanClass.tpe)
-          val body   = methodBodyTyper.virtualizedMatch(match_ addAttachment DefaultOverrideMatchAttachment(FALSE_typed), mode, BooleanClass.tpe)
+          val body   = methodBodyTyper.virtualizedMatch(match_ updateAttachment DefaultOverrideMatchAttachment(FALSE_typed), mode, BooleanClass.tpe)
 
           DefDef(methodSym, body)
         }
@@ -2622,7 +2622,7 @@ trait Typers extends Modes with Adaptations with Tags {
         // todo. investigate whether something can be done about this
         val att = templ.attachments.get[CompoundTypeTreeOriginalAttachment].getOrElse(CompoundTypeTreeOriginalAttachment(Nil, Nil))
         templ.removeAttachment[CompoundTypeTreeOriginalAttachment]
-        templ addAttachment att.copy(stats = stats1)
+        templ updateAttachment att.copy(stats = stats1)
         for (stat <- stats1 if stat.isDef) {
           val member = stat.symbol
           if (!(context.owner.ancestors forall
@@ -4947,7 +4947,7 @@ trait Typers extends Modes with Adaptations with Tags {
           //Console.println("Owner: " + context.enclClass.owner + " " + context.enclClass.owner.id)
           val self = refinedType(parents1 map (_.tpe), context.enclClass.owner, decls, templ.pos)
           newTyper(context.make(templ, self.typeSymbol, decls)).typedRefinement(templ)
-          templ addAttachment CompoundTypeTreeOriginalAttachment(parents1, Nil) // stats are set elsewhere
+          templ updateAttachment CompoundTypeTreeOriginalAttachment(parents1, Nil) // stats are set elsewhere
           tree setType self
         }
       }
diff --git a/src/compiler/scala/tools/reflect/ToolBox.scala b/src/compiler/scala/tools/reflect/ToolBox.scala
index 85e2b6543f..9e7d230a6a 100644
--- a/src/compiler/scala/tools/reflect/ToolBox.scala
+++ b/src/compiler/scala/tools/reflect/ToolBox.scala
@@ -80,18 +80,23 @@ trait ToolBox[U <: Universe] {
   def resetLocalAttrs(tree: u.Tree): u.Tree
 
   /** .. */
-  def parseExpr(code: String): u.Tree
+  def parse(code: String): u.Tree
 
-  /** Compiles and runs a tree using this ToolBox.
+  /** Compiles a tree using this ToolBox.
    *
    *  If the tree has unresolved type variables (represented as instances of `FreeTypeSymbol` symbols),
    *  then they all have to be resolved first using `Tree.substituteTypes`, or an error occurs.
    *
    *  This spawns the compiler at the Namer phase, and pipelines the tree through that compiler.
-   *  Currently `runExpr` does not accept trees that already typechecked, because typechecking isn't idempotent.
+   *  Currently `compile` does not accept trees that already typechecked, because typechecking isn't idempotent.
    *  For more info, take a look at https://issues.scala-lang.org/browse/SI-5464.
    */
-  def runExpr(tree: u.Tree): Any
+  def compile(tree: u.Tree): () => Any
+
+  /** Compiles and runs a tree using this ToolBox.
+   *  Is equivalent to `compile(tree)()`.
+   */
+  def eval(tree: u.Tree): Any
 }
 
 /** Represents an error during toolboxing
diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
index b658491294..b671a2eb48 100644
--- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
+++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
@@ -47,7 +47,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
         newTermName("__wrapper$" + wrapCount + "$" + java.util.UUID.randomUUID.toString.replace("-", ""))
       }
 
-      def verifyExpr(expr: Tree): Unit = {
+      def verify(expr: Tree): Unit = {
         // Previously toolboxes used to typecheck their inputs before compiling.
         // Actually, the initial demo by Martin first typechecked the reified tree,
         // then ran it, which typechecked it again, and only then launched the
@@ -97,7 +97,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
       }
 
       def transformDuringTyper(expr0: Tree, withImplicitViewsDisabled: Boolean, withMacrosDisabled: Boolean)(transform: (analyzer.Typer, Tree) => Tree): Tree = {
-        verifyExpr(expr0)
+        verify(expr0)
 
         // need to wrap the expr, because otherwise you won't be able to typecheck macros against something that contains free vars
         var (expr, freeTerms) = extractFreeTerms(expr0, wrapFreeTermRefs = false)
@@ -140,7 +140,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
         unwrapped
       }
 
-      def typeCheckExpr(expr: Tree, pt: Type, silent: Boolean, withImplicitViewsDisabled: Boolean, withMacrosDisabled: Boolean): Tree =
+      def typeCheck(expr: Tree, pt: Type, silent: Boolean, withImplicitViewsDisabled: Boolean, withMacrosDisabled: Boolean): Tree =
         transformDuringTyper(expr, withImplicitViewsDisabled = withImplicitViewsDisabled, withMacrosDisabled = withMacrosDisabled)(
           (currentTyper, expr) => {
             trace("typing (implicit views = %s, macros = %s): ".format(!withImplicitViewsDisabled, !withMacrosDisabled))(showAttributed(expr, true, true, settings.Yshowsymkinds.value))
@@ -170,10 +170,12 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
             }
           })
 
-      def compileExpr(expr: Tree): (Object, java.lang.reflect.Method) = {
-        verifyExpr(expr)
+      def compile(expr: Tree): () => Any = {
+        val freeTerms = expr.freeTerms // need to calculate them here, because later on they will be erased
+        val thunks = freeTerms map (fte => () => fte.value) // need to be lazy in order not to distort evaluation order
+        verify(expr)
 
-        def wrapExpr(expr0: Tree): Tree = {
+        def wrap(expr0: Tree): Tree = {
           val (expr, freeTerms) = extractFreeTerms(expr0, wrapFreeTermRefs = true)
 
           val (obj, mclazz) = rootMirror.EmptyPackageClass.newModuleAndClassSymbol(
@@ -214,7 +216,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
           cleanedUp
         }
 
-        val mdef = wrapExpr(expr)
+        val mdef = wrap(expr)
         val pdef = PackageDef(Ident(nme.EMPTY_PACKAGE_NAME), List(mdef))
         val unit = new CompilationUnit(NoSourceFile)
         unit.body = pdef
@@ -231,12 +233,6 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
         val jmeth = jclazz.getDeclaredMethods.find(_.getName == wrapperMethodName).get
         val jfield = jclazz.getDeclaredFields.find(_.getName == NameTransformer.MODULE_INSTANCE_NAME).get
         val singleton = jfield.get(null)
-        (singleton, jmeth)
-      }
-
-      def runExpr(expr: Tree): Any = {
-        val freeTerms = expr.freeTerms // need to calculate them here, because later on they will be erased
-        val thunks = freeTerms map (fte => () => fte.value) // need to be lazy in order not to distort evaluation order
 
         // @odersky writes: Not sure we will be able to drop this. I forgot the reason why we dereference () functions,
         // but there must have been one. So I propose to leave old version in comments to be resurrected if the problem resurfaces.
@@ -250,13 +246,14 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
         //   val applyMeth = result.getClass.getMethod("apply")
         //   applyMeth.invoke(result)
         // }
-        val (singleton, jmeth) = compileExpr(expr)
-        val result = jmeth.invoke(singleton, thunks map (_.asInstanceOf[AnyRef]): _*)
-        if (jmeth.getReturnType == java.lang.Void.TYPE) ()
-        else result
+        () => {
+          val result = jmeth.invoke(singleton, thunks map (_.asInstanceOf[AnyRef]): _*)
+          if (jmeth.getReturnType == java.lang.Void.TYPE) ()
+          else result
+        }
       }
 
-      def parseExpr(code: String): Tree = {
+      def parse(code: String): Tree = {
         val run = new Run
         reporter.reset()
         val wrappedCode = "object wrapper {" + EOL + code + EOL + "}"
@@ -336,7 +333,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
       var cexpectedType: compiler.Type = importer.importType(expectedType)
 
       if (compiler.settings.verbose.value) println("typing "+ctree+", expectedType = "+expectedType)
-      val ttree: compiler.Tree = compiler.typeCheckExpr(ctree, cexpectedType, silent = silent, withImplicitViewsDisabled = withImplicitViewsDisabled, withMacrosDisabled = withMacrosDisabled)
+      val ttree: compiler.Tree = compiler.typeCheck(ctree, cexpectedType, silent = silent, withImplicitViewsDisabled = withImplicitViewsDisabled, withMacrosDisabled = withMacrosDisabled)
       val uttree = exporter.importTree(ttree)
       uttree
     }
@@ -379,20 +376,22 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
     def showAttributed(tree: u.Tree, printTypes: Boolean = true, printIds: Boolean = true, printKinds: Boolean = false): String =
       compiler.showAttributed(importer.importTree(tree), printTypes, printIds, printKinds)
 
-    def parseExpr(code: String): u.Tree = {
+    def parse(code: String): u.Tree = {
       if (compiler.settings.verbose.value) println("parsing "+code)
-      val ctree: compiler.Tree = compiler.parseExpr(code)
+      val ctree: compiler.Tree = compiler.parse(code)
       val utree = exporter.importTree(ctree)
       utree
     }
 
-    def runExpr(tree: u.Tree): Any = {
+    def compile(tree: u.Tree): () => Any = {
       if (compiler.settings.verbose.value) println("importing "+tree)
       var ctree: compiler.Tree = importer.importTree(tree)
 
-      if (compiler.settings.verbose.value) println("running "+ctree)
-      compiler.runExpr(ctree)
+      if (compiler.settings.verbose.value) println("compiling "+ctree)
+      compiler.compile(ctree)
     }
+
+    def eval(tree: u.Tree): Any = compile(tree)()
   }
 }
 
diff --git a/src/compiler/scala/tools/reflect/package.scala b/src/compiler/scala/tools/reflect/package.scala
index d5569e448d..901071d91a 100644
--- a/src/compiler/scala/tools/reflect/package.scala
+++ b/src/compiler/scala/tools/reflect/package.scala
@@ -27,7 +27,7 @@ package reflect {
     def eval: T = {
       val factory = new ToolBoxFactory[JavaUniverse](expr.mirror.universe) { val mirror = expr.mirror.asInstanceOf[this.u.Mirror] }
       val toolBox = factory.mkToolBox()
-      toolBox.runExpr(expr.tree.asInstanceOf[toolBox.u.Tree]).asInstanceOf[T]
+      toolBox.eval(expr.tree.asInstanceOf[toolBox.u.Tree]).asInstanceOf[T]
     }
   }
 }
diff --git a/src/library/scala/reflect/base/AnnotationInfos.scala b/src/library/scala/reflect/base/AnnotationInfos.scala
deleted file mode 100644
index f03644deef..0000000000
--- a/src/library/scala/reflect/base/AnnotationInfos.scala
+++ /dev/null
@@ -1,44 +0,0 @@
-package scala.reflect
-package base
-
-trait AnnotationInfos { self: Universe =>
-
-  type AnnotationInfo >: Null <: AnyRef
-  implicit val AnnotationInfoTag: ClassTag[AnnotationInfo]
-  val AnnotationInfo: AnnotationInfoExtractor
-
-  abstract class AnnotationInfoExtractor {
-    def apply(atp: Type, args: List[Tree], assocs: List[(Name, ClassfileAnnotArg)]): AnnotationInfo
-    def unapply(info: AnnotationInfo): Option[(Type, List[Tree], List[(Name, ClassfileAnnotArg)])]
-  }
-
-  type ClassfileAnnotArg >: Null <: AnyRef
-  implicit val ClassfileAnnotArgTag: ClassTag[ClassfileAnnotArg]
-
-  type LiteralAnnotArg >: Null <: AnyRef with ClassfileAnnotArg
-  implicit val LiteralAnnotArgTag: ClassTag[LiteralAnnotArg]
-  val LiteralAnnotArg: LiteralAnnotArgExtractor
-
-  abstract class LiteralAnnotArgExtractor {
-    def apply(const: Constant): LiteralAnnotArg
-    def unapply(arg: LiteralAnnotArg): Option[Constant]
-  }
-
-  type ArrayAnnotArg >: Null <: AnyRef with ClassfileAnnotArg
-  implicit val ArrayAnnotArgTag: ClassTag[ArrayAnnotArg]
-  val ArrayAnnotArg: ArrayAnnotArgExtractor
-
-  abstract class ArrayAnnotArgExtractor {
-    def apply(args: Array[ClassfileAnnotArg]): ArrayAnnotArg
-    def unapply(arg: ArrayAnnotArg): Option[Array[ClassfileAnnotArg]]
-  }
-
-  type NestedAnnotArg >: Null <: AnyRef with ClassfileAnnotArg
-  implicit val NestedAnnotArgTag: ClassTag[NestedAnnotArg]
-  val NestedAnnotArg: NestedAnnotArgExtractor
-
-  abstract class NestedAnnotArgExtractor {
-    def apply(annInfo: AnnotationInfo): NestedAnnotArg
-    def unapply(arg: NestedAnnotArg): Option[AnnotationInfo]
-  }
-}
\ No newline at end of file
diff --git a/src/library/scala/reflect/base/Annotations.scala b/src/library/scala/reflect/base/Annotations.scala
new file mode 100644
index 0000000000..e3453b1cdf
--- /dev/null
+++ b/src/library/scala/reflect/base/Annotations.scala
@@ -0,0 +1,46 @@
+package scala.reflect
+package base
+
+import scala.collection.immutable.ListMap
+
+trait Annotations { self: Universe =>
+
+  type Annotation >: Null <: AnyRef
+  implicit val AnnotationTag: ClassTag[Annotation]
+  val Annotation: AnnotationExtractor
+
+  abstract class AnnotationExtractor {
+    def apply(tpe: Type, scalaArgs: List[Tree], javaArgs: ListMap[Name, JavaArgument]): Annotation
+    def unapply(ann: Annotation): Option[(Type, List[Tree], ListMap[Name, JavaArgument])]
+  }
+
+  type JavaArgument >: Null <: AnyRef
+  implicit val JavaArgumentTag: ClassTag[JavaArgument]
+
+  type LiteralArgument >: Null <: AnyRef with JavaArgument
+  implicit val LiteralArgumentTag: ClassTag[LiteralArgument]
+  val LiteralArgument: LiteralArgumentExtractor
+
+  abstract class LiteralArgumentExtractor {
+    def apply(value: Constant): LiteralArgument
+    def unapply(arg: LiteralArgument): Option[Constant]
+  }
+
+  type ArrayArgument >: Null <: AnyRef with JavaArgument
+  implicit val ArrayArgumentTag: ClassTag[ArrayArgument]
+  val ArrayArgument: ArrayArgumentExtractor
+
+  abstract class ArrayArgumentExtractor {
+    def apply(args: Array[JavaArgument]): ArrayArgument
+    def unapply(arg: ArrayArgument): Option[Array[JavaArgument]]
+  }
+
+  type NestedArgument >: Null <: AnyRef with JavaArgument
+  implicit val NestedArgumentTag: ClassTag[NestedArgument]
+  val NestedArgument: NestedArgumentExtractor
+
+  abstract class NestedArgumentExtractor {
+    def apply(annotation: Annotation): NestedArgument
+    def unapply(arg: NestedArgument): Option[Annotation]
+  }
+}
\ No newline at end of file
diff --git a/src/library/scala/reflect/base/Attachments.scala b/src/library/scala/reflect/base/Attachments.scala
index 43e870fc4f..889ac0ac14 100644
--- a/src/library/scala/reflect/base/Attachments.scala
+++ b/src/library/scala/reflect/base/Attachments.scala
@@ -20,15 +20,18 @@ abstract class Attachments { self =>
   /** Gets the underlying payload */
   def all: Set[Any] = Set.empty
 
+  private def matchesTag[T: ClassTag](datum: Any) =
+    classTag[T].runtimeClass == datum.getClass
+
   def get[T: ClassTag]: Option[T] =
-    (all find (_.getClass == classTag[T].runtimeClass)).asInstanceOf[Option[T]]
+    (all filter matchesTag[T]).headOption.asInstanceOf[Option[T]]
 
   /** Creates a copy of this attachment with its payload updated */
-  def add(attachment: Any): Attachments { type Pos = self.Pos } =
-    new NonemptyAttachments(this.pos, all + attachment)
+  def update[T: ClassTag](attachment: T): Attachments { type Pos = self.Pos } =
+    new NonemptyAttachments(this.pos, remove[T].all + attachment)
 
   def remove[T: ClassTag]: Attachments { type Pos = self.Pos } = {
-    val newAll = all filterNot (_.getClass == classTag[T].runtimeClass)
+    val newAll = all filterNot matchesTag[T]
     if (newAll.isEmpty) pos.asInstanceOf[Attachments { type Pos = self.Pos }]
     else new NonemptyAttachments(this.pos, newAll)
   }
diff --git a/src/library/scala/reflect/base/Base.scala b/src/library/scala/reflect/base/Base.scala
index 33582675bd..29bf2df656 100644
--- a/src/library/scala/reflect/base/Base.scala
+++ b/src/library/scala/reflect/base/Base.scala
@@ -5,6 +5,7 @@ import java.io.PrintWriter
 import scala.annotation.switch
 import scala.ref.WeakReference
 import scala.collection.mutable
+import scala.collection.immutable.ListMap
 
 class Base extends Universe { self =>
 
@@ -157,7 +158,7 @@ class Base extends Universe { self =>
   object ExistentialType extends ExistentialTypeExtractor
   implicit val ExistentialTypeTag = ClassTag[ExistentialType](classOf[ExistentialType])
 
-  case class AnnotatedType(annotations: List[AnnotationInfo], underlying: Type, selfsym: Symbol) extends Type { override def typeSymbol = underlying.typeSymbol }
+  case class AnnotatedType(annotations: List[Annotation], underlying: Type, selfsym: Symbol) extends Type { override def typeSymbol = underlying.typeSymbol }
   object AnnotatedType extends AnnotatedTypeExtractor
   implicit val AnnotatedTypeTag = ClassTag[AnnotatedType](classOf[AnnotatedType])
 
@@ -249,24 +250,24 @@ class Base extends Universe { self =>
   object Constant extends ConstantExtractor
   implicit val ConstantTag = ClassTag[Constant](classOf[Constant])
 
-  case class AnnotationInfo(atp: Type, args: List[Tree], assocs: List[(Name, ClassfileAnnotArg)])
-  object AnnotationInfo extends AnnotationInfoExtractor
-  implicit val AnnotationInfoTag = ClassTag[AnnotationInfo](classOf[AnnotationInfo])
+  case class Annotation(tpe: Type, scalaArgs: List[Tree], javaArgs: ListMap[Name, JavaArgument])
+  object Annotation extends AnnotationExtractor
+  implicit val AnnotationTag = ClassTag[Annotation](classOf[Annotation])
 
-  abstract class ClassfileAnnotArg
-  implicit val ClassfileAnnotArgTag = ClassTag[ClassfileAnnotArg](classOf[ClassfileAnnotArg])
+  abstract class JavaArgument
+  implicit val JavaArgumentTag = ClassTag[JavaArgument](classOf[JavaArgument])
 
-  case class LiteralAnnotArg(const: Constant) extends ClassfileAnnotArg
-  object LiteralAnnotArg extends LiteralAnnotArgExtractor
-  implicit val LiteralAnnotArgTag = ClassTag[LiteralAnnotArg](classOf[LiteralAnnotArg])
+  case class LiteralArgument(value: Constant) extends JavaArgument
+  object LiteralArgument extends LiteralArgumentExtractor
+  implicit val LiteralArgumentTag = ClassTag[LiteralArgument](classOf[LiteralArgument])
 
-  case class ArrayAnnotArg(args: Array[ClassfileAnnotArg]) extends ClassfileAnnotArg
-  object ArrayAnnotArg extends ArrayAnnotArgExtractor
-  implicit val ArrayAnnotArgTag = ClassTag[ArrayAnnotArg](classOf[ArrayAnnotArg])
+  case class ArrayArgument(args: Array[JavaArgument]) extends JavaArgument
+  object ArrayArgument extends ArrayArgumentExtractor
+  implicit val ArrayArgumentTag = ClassTag[ArrayArgument](classOf[ArrayArgument])
 
-  case class NestedAnnotArg(annInfo: AnnotationInfo) extends ClassfileAnnotArg
-  object NestedAnnotArg extends NestedAnnotArgExtractor
-  implicit val NestedAnnotArgTag = ClassTag[NestedAnnotArg](classOf[NestedAnnotArg])
+  case class NestedArgument(annotation: Annotation) extends JavaArgument
+  object NestedArgument extends NestedArgumentExtractor
+  implicit val NestedArgumentTag = ClassTag[NestedArgument](classOf[NestedArgument])
 
   class Position extends Attachments {
     override type Pos = Position
@@ -319,7 +320,7 @@ class Base extends Universe { self =>
 
     def setTypeSignature[S <: Symbol](sym: S, tpe: Type): S = sym
 
-    def setAnnotations[S <: Symbol](sym: S, annots: List[AnnotationInfo]): S = sym
+    def setAnnotations[S <: Symbol](sym: S, annots: List[Annotation]): S = sym
 
     def flagsFromBits(bits: Long): FlagSet = bits
 
@@ -623,10 +624,6 @@ class Base extends Universe { self =>
        extends GenericApply
   object Apply extends ApplyExtractor
 
-  case class ApplyDynamic(qual: Tree, args: List[Tree])
-       extends TermTree with SymTree
-  object ApplyDynamic extends ApplyDynamicExtractor
-
   case class Super(qual: Tree, mix: TypeName) extends TermTree
   object Super extends SuperExtractor
 
@@ -725,7 +722,6 @@ class Base extends Universe { self =>
   implicit val GenericApplyTag = ClassTag[GenericApply](classOf[GenericApply])
   implicit val TypeApplyTag = ClassTag[TypeApply](classOf[TypeApply])
   implicit val ApplyTag = ClassTag[Apply](classOf[Apply])
-  implicit val ApplyDynamicTag = ClassTag[ApplyDynamic](classOf[ApplyDynamic])
   implicit val SuperTag = ClassTag[Super](classOf[Super])
   implicit val ThisTag = ClassTag[This](classOf[This])
   implicit val SelectTag = ClassTag[Select](classOf[Select])
diff --git a/src/library/scala/reflect/base/BuildUtils.scala b/src/library/scala/reflect/base/BuildUtils.scala
index c4231dd515..e4710316e2 100644
--- a/src/library/scala/reflect/base/BuildUtils.scala
+++ b/src/library/scala/reflect/base/BuildUtils.scala
@@ -49,7 +49,7 @@ trait BuildUtils { self: Universe =>
 
     /** Set symbol's annotations to given annotations `annots`.
      */
-    def setAnnotations[S <: Symbol](sym: S, annots: List[AnnotationInfo]): S
+    def setAnnotations[S <: Symbol](sym: S, annots: List[Annotation]): S
 
     def flagsFromBits(bits: Long): FlagSet
 
diff --git a/src/library/scala/reflect/base/Trees.scala b/src/library/scala/reflect/base/Trees.scala
index 224965a2b7..78174f354c 100644
--- a/src/library/scala/reflect/base/Trees.scala
+++ b/src/library/scala/reflect/base/Trees.scala
@@ -605,10 +605,30 @@ trait Trees { self: Universe =>
     def unapply(bind: Bind): Option[(Name, Tree)]
   }
 
-  /** Noone knows what this is.
-   *  It is not idempotent w.r.t typechecking.
-   *  Can we, please, remove it?
+  /** Used to represent `unapply` methods in pattern matching.
    *  Introduced by typer, eliminated by patmat/explicitouter.
+   *
+   *  For example:
+   *  {{{
+   *    2 match { case Foo(x) => x }
+   *  }}}
+   *
+   *  Is represented as:
+   *  {{{
+   *    Match(
+   *      Literal(Constant(2)),
+   *      List(
+   *        CaseDef(
+   *          UnApply(
+   *            // a dummy node that carries the type of unapplication to patmat
+   *            // the <unapply-selector> here doesn't have an underlying symbol
+   *            // it only has a type assigned, therefore after `resetAllAttrs` this tree is no longer typeable
+   *            Apply(Select(Ident(Foo), newTermName("unapply")), List(Ident(newTermName("<unapply-selector>")))),
+   *            // arguments of the unapply => nothing synthetic here
+   *            List(Bind(newTermName("x"), Ident(nme.WILDCARD)))),
+   *          EmptyTree,
+   *          Ident(newTermName("x")))))
+   *  }}}
    */
   type UnApply >: Null <: TermTree
 
@@ -971,36 +991,6 @@ trait Trees { self: Universe =>
     def unapply(apply: Apply): Option[(Tree, List[Tree])]
   }
 
-  /** Dynamic value application.
-   *  In a dynamic application   q.f(as)
-   *   - q is stored in qual
-   *   - as is stored in args
-   *   - f is stored as the node's symbol field.
-   *  [Eugene++] what is it used for?
-   *  Introduced by erasure, eliminated by cleanup.
-   */
-  type ApplyDynamic >: Null <: TermTree with SymTree
-
-  /** A tag that preserves the identity of the `ApplyDynamic` abstract type from erasure.
-   *  Can be used for pattern matching, instance tests, serialization and likes.
-   */
-  implicit val ApplyDynamicTag: ClassTag[ApplyDynamic]
-
-  /** The constructor/deconstructor for `ApplyDynamic` instances. */
-  val ApplyDynamic: ApplyDynamicExtractor
-
-  /** An extractor class to create and pattern match with syntax `ApplyDynamic(qual, args)`.
-   *  This AST node corresponds to the following Scala code:
-   *
-   *    fun(args)
-   *
-   *  The symbol of an ApplyDynamic is the function symbol of `qual`, or NoSymbol, if there is none.
-   */
-  abstract class ApplyDynamicExtractor {
-    def apply(qual: Tree, args: List[Tree]): ApplyDynamic
-    def unapply(applyDynamic: ApplyDynamic): Option[(Tree, List[Tree])]
-  }
-
   /** Super reference, qual = corresponding this reference
    *  A super reference C.super[M] is represented as Super(This(C), M).
    */
diff --git a/src/library/scala/reflect/base/Types.scala b/src/library/scala/reflect/base/Types.scala
index b016b77f36..839c49805a 100644
--- a/src/library/scala/reflect/base/Types.scala
+++ b/src/library/scala/reflect/base/Types.scala
@@ -362,8 +362,8 @@ trait Types { self: Universe =>
    *  `selfSym` is a symbol representing the annotated type itself.
    */
   abstract class AnnotatedTypeExtractor {
-    def apply(annotations: List[AnnotationInfo], underlying: Type, selfsym: Symbol): AnnotatedType
-    def unapply(tpe: AnnotatedType): Option[(List[AnnotationInfo], Type, Symbol)]
+    def apply(annotations: List[Annotation], underlying: Type, selfsym: Symbol): AnnotatedType
+    def unapply(tpe: AnnotatedType): Option[(List[Annotation], Type, Symbol)]
   }
 
   /** The `TypeBounds` type signature is used to indicate lower and upper type bounds
diff --git a/src/library/scala/reflect/base/Universe.scala b/src/library/scala/reflect/base/Universe.scala
index 18599ad092..11290401ec 100644
--- a/src/library/scala/reflect/base/Universe.scala
+++ b/src/library/scala/reflect/base/Universe.scala
@@ -8,7 +8,7 @@ abstract class Universe extends Symbols
                            with Names
                            with Trees
                            with Constants
-                           with AnnotationInfos
+                           with Annotations
                            with Positions
                            with Exprs
                            with TypeTags
diff --git a/src/reflect/scala/reflect/api/AnnotationInfos.scala b/src/reflect/scala/reflect/api/AnnotationInfos.scala
deleted file mode 100644
index d9f35024d9..0000000000
--- a/src/reflect/scala/reflect/api/AnnotationInfos.scala
+++ /dev/null
@@ -1,27 +0,0 @@
-package scala.reflect
-package api
-
-trait AnnotationInfos extends base.AnnotationInfos { self: Universe =>
-
-  override type AnnotationInfo >: Null <: AnyRef with AnnotationInfoApi
-  trait AnnotationInfoApi {
-    def atp: Type
-    def args: List[Tree]
-    def assocs: List[(Name, ClassfileAnnotArg)]
-  }
-
-  override type LiteralAnnotArg >: Null <: ClassfileAnnotArg with LiteralAnnotArgApi
-  trait LiteralAnnotArgApi {
-    def const: Constant
-  }
-
-  override type ArrayAnnotArg >: Null <: ClassfileAnnotArg with ArrayAnnotArgApi
-  trait ArrayAnnotArgApi {
-    def args: Array[ClassfileAnnotArg]
-  }
-
-  override type NestedAnnotArg >: Null <: ClassfileAnnotArg with NestedAnnotArgApi
-  trait NestedAnnotArgApi {
-    def annInfo: AnnotationInfo
-  }
-}
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/api/Annotations.scala b/src/reflect/scala/reflect/api/Annotations.scala
new file mode 100644
index 0000000000..43e95f9902
--- /dev/null
+++ b/src/reflect/scala/reflect/api/Annotations.scala
@@ -0,0 +1,29 @@
+package scala.reflect
+package api
+
+import scala.collection.immutable.ListMap
+
+trait Annotations extends base.Annotations { self: Universe =>
+
+  override type Annotation >: Null <: AnyRef with AnnotationApi
+  trait AnnotationApi {
+    def tpe: Type
+    def scalaArgs: List[Tree]
+    def javaArgs: ListMap[Name, JavaArgument]
+  }
+
+  override type LiteralArgument >: Null <: JavaArgument with LiteralArgumentApi
+  trait LiteralArgumentApi {
+    def value: Constant
+  }
+
+  override type ArrayArgument >: Null <: JavaArgument with ArrayArgumentApi
+  trait ArrayArgumentApi {
+    def args: Array[JavaArgument]
+  }
+
+  override type NestedArgument >: Null <: JavaArgument with NestedArgumentApi
+  trait NestedArgumentApi {
+    def annotation: Annotation
+  }
+}
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/api/Symbols.scala b/src/reflect/scala/reflect/api/Symbols.scala
index 1fbbc0c0a4..cf1f574ade 100644
--- a/src/reflect/scala/reflect/api/Symbols.scala
+++ b/src/reflect/scala/reflect/api/Symbols.scala
@@ -36,13 +36,8 @@ trait Symbols extends base.Symbols { self: Universe =>
     //        at scala.reflect.internal.pickling.UnPickler$Scan.run(UnPickler.scala:88)
     //        at scala.reflect.internal.pickling.UnPickler.unpickle(UnPickler.scala:37)
     //        at scala.reflect.runtime.JavaMirrors$JavaMirror.unpickleClass(JavaMirrors.scala:253)                 // unpickle from within a reflexive mirror
-    //    def annotations: List[AnnotationInfo]
-    def getAnnotations: List[AnnotationInfo]
-
-    /** Whether this symbol carries an annotation for which the given
-     *  symbol is its typeSymbol.
-     */
-    def hasAnnotation(sym: Symbol): Boolean
+    //    def annotations: List[Annotation]
+    def getAnnotations: List[Annotation]
 
     /** For a class: the module or case class factory with the same name in the same package.
      *  For a module: the class with the same name in the same package.
diff --git a/src/reflect/scala/reflect/api/Trees.scala b/src/reflect/scala/reflect/api/Trees.scala
index 5522693b29..e46a977be8 100644
--- a/src/reflect/scala/reflect/api/Trees.scala
+++ b/src/reflect/scala/reflect/api/Trees.scala
@@ -424,14 +424,6 @@ trait Trees extends base.Trees { self: Universe =>
   trait ApplyApi extends GenericApplyApi { this: Apply =>
   }
 
-  override type ApplyDynamic >: Null <: TermTree with SymTree with ApplyDynamicApi
-
-  /** The API that all apply dynamics support */
-  trait ApplyDynamicApi extends TermTreeApi with SymTreeApi { this: ApplyDynamic =>
-    val qual: Tree
-    val args: List[Tree]
-  }
-
   override type Super >: Null <: TermTree with SuperApi
 
   /** The API that all supers support */
@@ -586,7 +578,6 @@ trait Trees extends base.Trees { self: Universe =>
     def Typed(tree: Tree, expr: Tree, tpt: Tree): Typed
     def TypeApply(tree: Tree, fun: Tree, args: List[Tree]): TypeApply
     def Apply(tree: Tree, fun: Tree, args: List[Tree]): Apply
-    def ApplyDynamic(tree: Tree, qual: Tree, args: List[Tree]): ApplyDynamic
     def Super(tree: Tree, qual: Tree, mix: TypeName): Super
     def This(tree: Tree, qual: Name): This
     def Select(tree: Tree, qualifier: Tree, selector: Name): Select
diff --git a/src/reflect/scala/reflect/api/Types.scala b/src/reflect/scala/reflect/api/Types.scala
index f22f8d3e75..1c79de02c3 100644
--- a/src/reflect/scala/reflect/api/Types.scala
+++ b/src/reflect/scala/reflect/api/Types.scala
@@ -121,15 +121,6 @@ trait Types extends base.Types { self: Universe =>
      */
     def widen: Type
 
-    /** Map to a singleton type which is a subtype of this type.
-     *  The fallback implemented here gives:
-     *  {{{
-     *    T.narrow  =  (T {}).this.type
-     *  }}}
-     *  Overridden where we know more about where types come from.
-     */
-    def narrow: Type
-
     /******************* helpers *******************/
 
     /** Substitute symbols in `to` for corresponding occurrences of references to
@@ -264,7 +255,7 @@ trait Types extends base.Types { self: Universe =>
 
   /** The API that all annotated types support */
   trait AnnotatedTypeApi extends TypeApi { this: AnnotatedType =>
-    val annotations: List[AnnotationInfo]
+    val annotations: List[Annotation]
     val underlying: Type
     val selfsym: Symbol
   }
diff --git a/src/reflect/scala/reflect/api/Universe.scala b/src/reflect/scala/reflect/api/Universe.scala
index 3dce0f218e..3165f9abcd 100644
--- a/src/reflect/scala/reflect/api/Universe.scala
+++ b/src/reflect/scala/reflect/api/Universe.scala
@@ -14,4 +14,4 @@ abstract class Universe extends base.Universe
                            with StandardDefinitions
                            with StandardNames
                            with Importers
-                           with AnnotationInfos
+                           with Annotations
diff --git a/src/reflect/scala/reflect/internal/AnnotationInfos.scala b/src/reflect/scala/reflect/internal/AnnotationInfos.scala
index a444c786f7..8853b872c0 100644
--- a/src/reflect/scala/reflect/internal/AnnotationInfos.scala
+++ b/src/reflect/scala/reflect/internal/AnnotationInfos.scala
@@ -9,9 +9,10 @@ package internal
 import util._
 import pickling.ByteCodecs
 import scala.annotation.tailrec
+import scala.collection.immutable.ListMap
 
 /** AnnotationInfo and its helpers */
-trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
+trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
   import definitions.{ ThrowsClass, StaticAnnotationClass, isMetaAnnotation }
 
   // Common annotation code between Symbol and Type.
@@ -32,7 +33,7 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
       case AnnotationInfo(tp, Literal(Constant(tpe: Type)) :: Nil, _) if tp.typeSymbol == ThrowsClass => tpe.typeSymbol
     }
 
-    /** Tests for, get, or remove an annotation */    
+    /** Tests for, get, or remove an annotation */
     def hasAnnotation(cls: Symbol): Boolean =
       //OPT inlined from exists to save on #closures; was:  annotations exists (_ matches cls)
       dropOtherAnnotations(annotations, cls).nonEmpty
@@ -43,12 +44,12 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
         case ann :: _ => Some(ann)
         case _ => None
       }
-    
+
     def removeAnnotation(cls: Symbol): Self = filterAnnotations(ann => !(ann matches cls))
-    
+
     final def withAnnotation(annot: AnnotationInfo): Self = withAnnotations(List(annot))
 
-    @tailrec private 
+    @tailrec private
     def dropOtherAnnotations(anns: List[AnnotationInfo], cls: Symbol): List[AnnotationInfo] = anns match {
       case ann :: rest => if (ann matches cls) anns else dropOtherAnnotations(rest, cls)
       case Nil => Nil
@@ -63,28 +64,46 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
    *  - or nested classfile annotations
    */
   abstract class ClassfileAnnotArg extends Product
-  implicit val ClassfileAnnotArgTag = ClassTag[ClassfileAnnotArg](classOf[ClassfileAnnotArg])
+  implicit val JavaArgumentTag = ClassTag[ClassfileAnnotArg](classOf[ClassfileAnnotArg])
 
   /** Represents a compile-time Constant (`Boolean`, `Byte`, `Short`,
    *  `Char`, `Int`, `Long`, `Float`, `Double`, `String`, `java.lang.Class` or
    *  an instance of a Java enumeration value).
    */
   case class LiteralAnnotArg(const: Constant)
-  extends ClassfileAnnotArg with LiteralAnnotArgApi {
+  extends ClassfileAnnotArg with LiteralArgumentApi {
+    def value = const
     override def toString = const.escapedStringValue
   }
-  implicit val LiteralAnnotArgTag = ClassTag[LiteralAnnotArg](classOf[LiteralAnnotArg])
-
-  object LiteralAnnotArg extends LiteralAnnotArgExtractor
+  object LiteralAnnotArg extends LiteralArgumentExtractor
 
   /** Represents an array of classfile annotation arguments */
   case class ArrayAnnotArg(args: Array[ClassfileAnnotArg])
-  extends ClassfileAnnotArg with ArrayAnnotArgApi {
+  extends ClassfileAnnotArg with ArrayArgumentApi {
     override def toString = args.mkString("[", ", ", "]")
   }
-  implicit val ArrayAnnotArgTag = ClassTag[ArrayAnnotArg](classOf[ArrayAnnotArg])
+  object ArrayAnnotArg extends ArrayArgumentExtractor
 
-  object ArrayAnnotArg extends ArrayAnnotArgExtractor
+  /** Represents a nested classfile annotation */
+  case class NestedAnnotArg(annInfo: AnnotationInfo)
+  extends ClassfileAnnotArg with NestedArgumentApi {
+    // The nested annotation should not have any Scala annotation arguments
+    assert(annInfo.args.isEmpty, annInfo.args)
+    def annotation = annInfo
+    override def toString = annInfo.toString
+  }
+  object NestedAnnotArg extends NestedArgumentExtractor
+
+  type JavaArgument = ClassfileAnnotArg
+  type LiteralArgument = LiteralAnnotArg
+  val LiteralArgument = LiteralAnnotArg
+  implicit val LiteralArgumentTag = ClassTag[LiteralAnnotArg](classOf[LiteralAnnotArg])
+  type ArrayArgument = ArrayAnnotArg
+  val ArrayArgument = ArrayAnnotArg
+  implicit val ArrayArgumentTag = ClassTag[ArrayAnnotArg](classOf[ArrayAnnotArg])
+  type NestedArgument = NestedAnnotArg
+  val NestedArgument = NestedAnnotArg
+  implicit val NestedArgumentTag = ClassTag[NestedAnnotArg](classOf[NestedAnnotArg])
 
   /** A specific annotation argument that encodes an array of bytes as an
    *  array of `Long`. The type of the argument declared in the annotation
@@ -121,20 +140,9 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
       }
       src
     }
-
   }
 
-  /** Represents a nested classfile annotation */
-  case class NestedAnnotArg(annInfo: AnnotationInfo) extends ClassfileAnnotArg with NestedAnnotArgApi {
-    // The nested annotation should not have any Scala annotation arguments
-    assert(annInfo.args.isEmpty, annInfo.args)
-    override def toString = annInfo.toString
-  }
-  implicit val NestedAnnotArgTag = ClassTag[NestedAnnotArg](classOf[NestedAnnotArg])
-
-  object NestedAnnotArg extends NestedAnnotArgExtractor
-
-  object AnnotationInfo extends AnnotationInfoExtractor {
+  object AnnotationInfo {
     def marker(atp: Type): AnnotationInfo =
       apply(atp, Nil, Nil)
 
@@ -207,11 +215,15 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
    *
    *  `assocs` stores arguments to classfile annotations as name-value pairs.
    */
-  sealed abstract class AnnotationInfo extends AnnotationInfoApi {
+  sealed abstract class AnnotationInfo extends AnnotationApi {
     def atp: Type
     def args: List[Tree]
     def assocs: List[(Name, ClassfileAnnotArg)]
 
+    def tpe = atp
+    def scalaArgs = args
+    def javaArgs = ListMap(assocs: _*)
+
     // necessary for reification, see Reifiers.scala for more info
     def original: Tree
     def setOriginal(t: Tree): this.type
@@ -299,7 +311,14 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
     }
   }
 
-  implicit val AnnotationInfoTag = ClassTag[AnnotationInfo](classOf[AnnotationInfo])
+  type Annotation = AnnotationInfo
+  object Annotation extends AnnotationExtractor {
+    def apply(tpe: Type, scalaArgs: List[Tree], javaArgs: ListMap[Name, ClassfileAnnotArg]): Annotation =
+      AnnotationInfo(tpe, scalaArgs, javaArgs.toList)
+    def unapply(annotation: Annotation): Option[(Type, List[Tree], ListMap[Name, ClassfileAnnotArg])] =
+      Some((annotation.tpe, annotation.scalaArgs, annotation.javaArgs))
+  }
+  implicit val AnnotationTag = ClassTag[AnnotationInfo](classOf[AnnotationInfo])
 
   object UnmappableAnnotation extends CompleteAnnotationInfo(NoType, Nil, Nil)
 }
diff --git a/src/reflect/scala/reflect/internal/StdAttachments.scala b/src/reflect/scala/reflect/internal/StdAttachments.scala
index 60b3a6f436..5f6a3bf777 100644
--- a/src/reflect/scala/reflect/internal/StdAttachments.scala
+++ b/src/reflect/scala/reflect/internal/StdAttachments.scala
@@ -10,7 +10,7 @@ trait StdAttachments {
   trait Attachable {
     protected var rawatt: base.Attachments { type Pos = Position } = NoPosition
     def attachments = rawatt
-    def addAttachment(attachment: Any): this.type = { rawatt = rawatt.add(attachment); this }
+    def updateAttachment[T: ClassTag](attachment: T): this.type = { rawatt = rawatt.update(attachment); this }
     def removeAttachment[T: ClassTag]: this.type = { rawatt = rawatt.remove[T]; this }
 
     // cannot be final due to SynchronizedSymbols
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index e70531df6e..22f5b391b8 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -571,7 +571,7 @@ trait StdNames {
     // Compiler utilized names
 
     val AnnotatedType: NameType        = "AnnotatedType"
-    val AnnotationInfo: NameType       = "AnnotationInfo"
+    val Annotation: NameType           = "Annotation"
     val Any: NameType                  = "Any"
     val AnyVal: NameType               = "AnyVal"
     val AppliedTypeTree: NameType      = "AppliedTypeTree"
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 430cf58a54..be55b72623 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -1600,7 +1600,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
           setInfo (this.info cloneInfo clone)
           setAnnotations this.annotations
       )
-      this.attachments.all.foreach(clone.addAttachment)
+      this.attachments.all.foreach(clone.updateAttachment)
       if (clone.thisSym != clone)
         clone.typeOfThis = (clone.typeOfThis cloneInfo clone)
 
diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index a59f01155a..b20c315a2a 100644
--- a/src/reflect/scala/reflect/internal/Trees.scala
+++ b/src/reflect/scala/reflect/internal/Trees.scala
@@ -400,9 +400,7 @@ trait Trees extends api.Trees { self: SymbolTable =>
 
   def ApplyConstructor(tpt: Tree, args: List[Tree]) = Apply(Select(New(tpt), nme.CONSTRUCTOR), args)
 
-  case class ApplyDynamic(qual: Tree, args: List[Tree])
-       extends SymTree with TermTree with ApplyDynamicApi
-  object ApplyDynamic extends ApplyDynamicExtractor
+  case class ApplyDynamic(qual: Tree, args: List[Tree]) extends SymTree with TermTree
 
   case class Super(qual: Tree, mix: TypeName) extends TermTree with SuperApi {
     override def symbol: Symbol = qual.symbol
@@ -496,7 +494,12 @@ trait Trees extends api.Trees { self: SymbolTable =>
 
   def TypeTree(tp: Type): TypeTree = TypeTree() setType tp
 
-  class StrictTreeCopier extends TreeCopierOps {
+  override type TreeCopier <: InternalTreeCopierOps
+  abstract class InternalTreeCopierOps extends TreeCopierOps {
+    def ApplyDynamic(tree: Tree, qual: Tree, args: List[Tree]): ApplyDynamic
+  }
+
+  class StrictTreeCopier extends InternalTreeCopierOps {
     def ClassDef(tree: Tree, mods: Modifiers, name: Name, tparams: List[TypeDef], impl: Template) =
       new ClassDef(mods, name.toTypeName, tparams, impl).copyAttrs(tree)
     def PackageDef(tree: Tree, pid: RefTree, stats: List[Tree]) =
@@ -590,7 +593,7 @@ trait Trees extends api.Trees { self: SymbolTable =>
       new ExistentialTypeTree(tpt, whereClauses).copyAttrs(tree)
   }
 
-  class LazyTreeCopier extends TreeCopierOps {
+  class LazyTreeCopier extends InternalTreeCopierOps {
     val treeCopy: TreeCopier = newStrictTreeCopier
     def ClassDef(tree: Tree, mods: Modifiers, name: Name, tparams: List[TypeDef], impl: Template) = tree match {
       case t @ ClassDef(mods0, name0, tparams0, impl0)
@@ -1585,7 +1588,6 @@ trait Trees extends api.Trees { self: SymbolTable =>
   implicit val GenericApplyTag = ClassTag[GenericApply](classOf[GenericApply])
   implicit val TypeApplyTag = ClassTag[TypeApply](classOf[TypeApply])
   implicit val ApplyTag = ClassTag[Apply](classOf[Apply])
-  implicit val ApplyDynamicTag = ClassTag[ApplyDynamic](classOf[ApplyDynamic])
   implicit val SuperTag = ClassTag[Super](classOf[Super])
   implicit val ThisTag = ClassTag[This](classOf[This])
   implicit val SelectTag = ClassTag[Select](classOf[Select])
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index 1dae6e70b7..a9994a037f 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -446,7 +446,7 @@ abstract class UnPickler /*extends scala.reflect.generic.UnPickler*/ {
     private def readArrayAnnot() = {
       readByte() // skip the `annotargarray` tag
       val end = readNat() + readIndex
-      until(end, () => readClassfileAnnotArg(readNat())).toArray(ClassfileAnnotArgTag)
+      until(end, () => readClassfileAnnotArg(readNat())).toArray(JavaArgumentTag)
     }
     protected def readClassfileAnnotArg(i: Int): ClassfileAnnotArg = bytes(index(i)) match {
       case ANNOTINFO     => NestedAnnotArg(at(i, readAnnotation))
diff --git a/src/reflect/scala/reflect/macros/Infrastructure.scala b/src/reflect/scala/reflect/macros/Infrastructure.scala
index f01725cd1d..80153ff257 100644
--- a/src/reflect/scala/reflect/macros/Infrastructure.scala
+++ b/src/reflect/scala/reflect/macros/Infrastructure.scala
@@ -43,7 +43,7 @@ trait Infrastructure {
    *      val importer = ru.mkImporter(c.universe).asInstanceOf[ru.Importer { val from: c.universe.type }]
    *      val tree = c.resetAllAttrs(x.tree.duplicate)
    *      val imported = importer.importTree(tree)
-   *      val valueOfX = toolBox.runExpr(imported).asInstanceOf[T]
+   *      val valueOfX = toolBox.eval(imported).asInstanceOf[T]
    *      ...
    *    }
    */
@@ -77,23 +77,4 @@ trait Infrastructure {
   /** Returns a macro definition which triggered this macro expansion.
    */
   val currentMacro: Symbol
-
-  // todo. redo caches as discussed on Reflecting Meeting 2012/03/29
-  // https://docs.google.com/document/d/1oUZGQpdt2qwioTlJcSt8ZFQwVLTvpxn8xa67P8OGVpU/edit
-
-  /** A cache shared by all invocations of all macros across all compilation runs.
-   *
-   *  Needs to be used with extreme care, since memory leaks here will swiftly crash the presentation compiler.
-   *  For example, Scala IDE typically launches a compiler run on every edit action so there might be hundreds of runs per minute.
-   */
-  val globalCache: scala.collection.mutable.Map[Any, Any]
-
-  /** A cache shared by all invocations of the same macro within a single compilation run.
-   *
-   *  This cache is cleared automatically after a compilation run is completed or abandoned.
-   *  It is also specific to a particular macro definition.
-   *
-   *  To share data between different macros and/or different compilation runs, use ``globalCache''.
-   */
-  val cache: scala.collection.mutable.Map[Any, Any]
 }
diff --git a/src/reflect/scala/reflect/macros/Parsers.scala b/src/reflect/scala/reflect/macros/Parsers.scala
index ea87c5842e..1742d07b60 100644
--- a/src/reflect/scala/reflect/macros/Parsers.scala
+++ b/src/reflect/scala/reflect/macros/Parsers.scala
@@ -5,7 +5,7 @@ trait Parsers {
   self: Context =>
 
   /** .. */
-  // todo. distinguish between `parseExpr` and `parse`
+  // todo. distinguish between `parse` and `parse`
   def parse(code: String): Tree
 
   /** Represents an error during parsing
diff --git a/src/reflect/scala/reflect/macros/Universe.scala b/src/reflect/scala/reflect/macros/Universe.scala
index 06428ee3fc..7fa2e7cbae 100644
--- a/src/reflect/scala/reflect/macros/Universe.scala
+++ b/src/reflect/scala/reflect/macros/Universe.scala
@@ -10,7 +10,7 @@ abstract class Universe extends scala.reflect.api.Universe {
     def attachments: base.Attachments { type Pos = Position }
 
     /** ... */
-    def addAttachment(attachment: Any): AttachableApi.this.type
+    def updateAttachment[T: ClassTag](attachment: T): AttachableApi.this.type
 
     /** ... */
     def removeAttachment[T: ClassTag]: AttachableApi.this.type
@@ -32,7 +32,7 @@ abstract class Universe extends scala.reflect.api.Universe {
 
     def setTypeSignature(tpe: Type): Symbol
 
-    def setAnnotations(annots: AnnotationInfo*): Symbol
+    def setAnnotations(annots: Annotation*): Symbol
 
     def setName(name: Name): Symbol
 
diff --git a/src/reflect/scala/reflect/runtime/JavaUniverse.scala b/src/reflect/scala/reflect/runtime/JavaUniverse.scala
index 77d65a7db2..1d875b10f1 100644
--- a/src/reflect/scala/reflect/runtime/JavaUniverse.scala
+++ b/src/reflect/scala/reflect/runtime/JavaUniverse.scala
@@ -16,7 +16,7 @@ class JavaUniverse extends internal.SymbolTable with ReflectSetup with runtime.S
 
   def log(msg: => AnyRef): Unit = println(" [] "+msg)
 
-  type TreeCopier = TreeCopierOps
+  type TreeCopier = InternalTreeCopierOps
   def newStrictTreeCopier: TreeCopier = new StrictTreeCopier
   def newLazyTreeCopier: TreeCopier = new LazyTreeCopier