Merge pull request #1402 from scalamacros/topic/reflection

reflection and macro cleanup

55 files changed, 470 insertions, 716 deletions

diff --git a/src/compiler/scala/reflect/macros/runtime/Aliases.scala b/src/compiler/scala/reflect/macros/runtime/Aliases.scala
index 30e72997f7..ff870e728e 100644
--- a/src/compiler/scala/reflect/macros/runtime/Aliases.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Aliases.scala
@@ -10,17 +10,20 @@ trait Aliases {
   override type TermName = universe.TermName
   override type TypeName = universe.TypeName
   override type Tree = universe.Tree
-  // override type Position = universe.Position
+  override type Position = universe.Position
   override type Scope = universe.Scope
   override type Modifiers = universe.Modifiers
 
   override type Expr[+T] = universe.Expr[T]
   override val Expr = universe.Expr
+  def Expr[T: WeakTypeTag](tree: Tree): Expr[T] = universe.Expr[T](mirror, universe.FixedMirrorTreeCreator(mirror, tree))
 
   override type WeakTypeTag[T] = universe.WeakTypeTag[T]
   override type TypeTag[T] = universe.TypeTag[T]
   override val WeakTypeTag = universe.WeakTypeTag
   override val TypeTag = universe.TypeTag
+  def WeakTypeTag[T](tpe: Type): WeakTypeTag[T] = universe.WeakTypeTag[T](mirror, universe.FixedMirrorTypeCreator(mirror, tpe))
+  def TypeTag[T](tpe: Type): TypeTag[T] = universe.TypeTag[T](mirror, universe.FixedMirrorTypeCreator(mirror, tpe))
   override def weakTypeTag[T](implicit attag: WeakTypeTag[T]) = attag
   override def typeTag[T](implicit ttag: TypeTag[T]) = ttag
   override def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type = attag.tpe
diff --git a/src/compiler/scala/reflect/macros/runtime/CapturedVariables.scala b/src/compiler/scala/reflect/macros/runtime/CapturedVariables.scala
deleted file mode 100644
index 78fb7100b0..0000000000
--- a/src/compiler/scala/reflect/macros/runtime/CapturedVariables.scala
+++ /dev/null
@@ -1,15 +0,0 @@
-package scala.reflect.macros
-package runtime
-
-trait CapturedVariables {
-  self: Context =>
-
-  import mirror._
-  import universe._
-
-  def captureVariable(vble: Symbol): Unit = universe.captureVariable(vble)
-
-  def referenceCapturedVariable(vble: Symbol): Tree = universe.referenceCapturedVariable(vble)
-
-  def capturedVariableType(vble: Symbol): Type = universe.capturedVariableType(vble)
-}
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/macros/runtime/Context.scala b/src/compiler/scala/reflect/macros/runtime/Context.scala
index 8bbfef44a3..8e8b0fcea1 100644
--- a/src/compiler/scala/reflect/macros/runtime/Context.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Context.scala
@@ -5,24 +5,20 @@ import scala.tools.nsc.Global
 
 abstract class Context extends scala.reflect.macros.Context
                          with Aliases
-                         with CapturedVariables
-                         with Infrastructure
                          with Enclosures
                          with Names
                          with Reifiers
                          with FrontEnds
-                         with Settings
+                         with Infrastructure
                          with Typers
                          with Parsers
-                         with Exprs
-                         with TypeTags
                          with Evals
                          with ExprUtils
                          with Traces {
 
   val universe: Global
 
-  val mirror: MirrorOf[universe.type] = universe.rootMirror
+  val mirror: universe.Mirror = universe.rootMirror
 
   val callsiteTyper: universe.analyzer.Typer
 
diff --git a/src/compiler/scala/reflect/macros/runtime/Enclosures.scala b/src/compiler/scala/reflect/macros/runtime/Enclosures.scala
index b5c988ca83..be5f2dbe83 100644
--- a/src/compiler/scala/reflect/macros/runtime/Enclosures.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Enclosures.scala
@@ -19,5 +19,6 @@ trait Enclosures {
   val enclosingMacros: List[Context]         = this :: universe.analyzer.openMacros // include self
   val enclosingMethod: Tree                  = site.enclMethod.tree
   val enclosingPosition: Position            = if (enclPoses.isEmpty) NoPosition else enclPoses.head.pos
-  val enclosingUnit: CompilationUnit         = currentRun.currentUnit
+  val enclosingUnit: CompilationUnit         = universe.currentRun.currentUnit
+  val enclosingRun: Run                      = universe.currentRun
 }
diff --git a/src/compiler/scala/reflect/macros/runtime/Evals.scala b/src/compiler/scala/reflect/macros/runtime/Evals.scala
index acafeb5b02..1f7b5f2ff1 100644
--- a/src/compiler/scala/reflect/macros/runtime/Evals.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Evals.scala
@@ -7,7 +7,7 @@ import scala.tools.reflect.ToolBox
 trait Evals {
   self: Context =>
 
-  private lazy val evalMirror = ru.runtimeMirror(libraryClassLoader)
+  private lazy val evalMirror = ru.runtimeMirror(universe.analyzer.macroClassloader)
   private lazy val evalToolBox = evalMirror.mkToolBox()
   private lazy val evalImporter = ru.mkImporter(universe).asInstanceOf[ru.Importer { val from: universe.type }]
 
diff --git a/src/compiler/scala/reflect/macros/runtime/Exprs.scala b/src/compiler/scala/reflect/macros/runtime/Exprs.scala
deleted file mode 100644
index ebf8fa2b96..0000000000
--- a/src/compiler/scala/reflect/macros/runtime/Exprs.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-package scala.reflect.macros
-package runtime
-
-trait Exprs {
-  self: Context =>
-
-  def Expr[T: WeakTypeTag](tree: Tree): Expr[T] = universe.Expr[T](mirror, universe.FixedMirrorTreeCreator(mirror, tree))
-}
diff --git a/src/compiler/scala/reflect/macros/runtime/FrontEnds.scala b/src/compiler/scala/reflect/macros/runtime/FrontEnds.scala
index 9f328eb82b..a6a198e1b4 100644
--- a/src/compiler/scala/reflect/macros/runtime/FrontEnds.scala
+++ b/src/compiler/scala/reflect/macros/runtime/FrontEnds.scala
@@ -1,28 +1,9 @@
 package scala.reflect.macros
 package runtime
 
-trait FrontEnds extends scala.tools.reflect.FrontEnds {
+trait FrontEnds {
   self: Context =>
 
-  import universe._
-  import mirror._
-
-  override type Position = universe.Position
-
-  def frontEnd: FrontEnd = wrapReporter(universe.reporter)
-
-  def setFrontEnd(frontEnd: FrontEnd): this.type = {
-    universe.reporter = wrapFrontEnd(frontEnd)
-    this
-  }
-
-  def withFrontEnd[T](frontEnd: FrontEnd)(op: => T): T = {
-    val old = universe.reporter
-    setFrontEnd(frontEnd)
-    try op
-    finally universe.reporter = old
-  }
-
   def echo(pos: Position, msg: String): Unit = universe.reporter.echo(pos, msg)
 
   def info(pos: Position, msg: String, force: Boolean): Unit = universe.reporter.info(pos, msg, force)
@@ -36,9 +17,4 @@ trait FrontEnds extends scala.tools.reflect.FrontEnds {
   def error(pos: Position, msg: String): Unit = callsiteTyper.context.error(pos, msg)
 
   def abort(pos: Position, msg: String): Nothing = throw new AbortMacroException(pos, msg)
-
-  def interactive(): Unit = universe.reporter match {
-    case reporter: scala.tools.nsc.reporters.AbstractReporter => reporter.displayPrompt()
-    case _ => ()
-  }
 }
diff --git a/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala b/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala
index 7157dbeaa2..7781693822 100644
--- a/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala
@@ -1,36 +1,16 @@
 package scala.reflect.macros
 package runtime
 
-import scala.tools.nsc.util.ScalaClassLoader
-
 trait Infrastructure {
   self: Context =>
 
-  val forJVM: Boolean = universe.forJVM
-
-  val forMSIL: Boolean = universe.forMSIL
-
-  val forInteractive: Boolean = universe.forInteractive
-
-  val forScaladoc: Boolean = universe.forScaladoc
-
-  val currentRun: Run = universe.currentRun
-
-  val libraryClassPath: List[java.net.URL] = universe.classPath.asURLs
-
-  lazy val libraryClassLoader: ClassLoader = universe.analyzer.macroClassloader
-
-  type Run = universe.Run
-
-  object Run extends RunExtractor {
-    def unapply(run: Run): Option[(CompilationUnit, List[CompilationUnit])] = Some((run.currentUnit, run.units.toList))
+  def settings: List[String] = {
+    val us = universe.settings
+    import us._
+    userSetSettings collectFirst { case x: MultiStringSetting if x.name == XmacroSettings.name => x.value } getOrElse Nil
   }
 
-  type CompilationUnit = universe.CompilationUnit
-
-  object CompilationUnit extends CompilationUnitExtractor {
-    def unapply(compilationUnit: CompilationUnit): Option[(java.io.File, Array[Char], Tree)] = Some((compilationUnit.source.file.file, compilationUnit.source.content, compilationUnit.body))
-  }
+  def compilerSettings: List[String] = universe.settings.recreateArgs
 
-  val currentMacro: Symbol = expandee.symbol
+  def classPath: List[java.net.URL] = global.classPath.asURLs
 }
diff --git a/src/compiler/scala/reflect/macros/runtime/Parsers.scala b/src/compiler/scala/reflect/macros/runtime/Parsers.scala
index 5096526fdb..ab9b94ec9f 100644
--- a/src/compiler/scala/reflect/macros/runtime/Parsers.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Parsers.scala
@@ -10,6 +10,7 @@ trait Parsers {
 
   def parse(code: String): Tree =
     // todo. provide decent implementation
+    // see `Typers.typedUseCase` for details
     try {
       import scala.reflect.runtime.{universe => ru}
       val parsed = ru.rootMirror.mkToolBox().parse(code)
@@ -17,9 +18,7 @@ trait Parsers {
       importer.importTree(parsed)
     } catch {
       case ToolBoxError(msg, cause) =>
+        // todo. provide a position
         throw new ParseError(universe.NoPosition, msg)
     }
-
-  case class ParseError(val pos: Position, val msg: String) extends Throwable(msg)
-  object ParseError extends ParseErrorExtractor
 }
diff --git a/src/compiler/scala/reflect/macros/runtime/Reifiers.scala b/src/compiler/scala/reflect/macros/runtime/Reifiers.scala
index f15a7ad502..9e11e5e26d 100644
--- a/src/compiler/scala/reflect/macros/runtime/Reifiers.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Reifiers.scala
@@ -13,8 +13,6 @@ trait Reifiers {
   import universe._
   import definitions._
 
-  lazy val runtimeUniverse: Tree = gen.mkRuntimeUniverseRef
-
   def reifyTree(universe: Tree, mirror: Tree, tree: Tree): Tree = {
     assert(ExprClass != NoSymbol)
     val result = scala.reflect.reify.`package`.reifyTree(self.universe)(callsiteTyper, universe, mirror, tree)
diff --git a/src/compiler/scala/reflect/macros/runtime/Settings.scala b/src/compiler/scala/reflect/macros/runtime/Settings.scala
deleted file mode 100644
index e9d9a17b81..0000000000
--- a/src/compiler/scala/reflect/macros/runtime/Settings.scala
+++ /dev/null
@@ -1,35 +0,0 @@
-package scala.reflect.macros
-package runtime
-
-trait Settings {
-  self: Context =>
-
-  def settings: List[String] = {
-    val us = universe.settings
-    import us._
-    userSetSettings collectFirst { case x: MultiStringSetting if x.name == XmacroSettings.name => x.value } getOrElse Nil
-  }
-
-  def compilerSettings: List[String] = universe.settings.recreateArgs
-
-  def setCompilerSettings(options: String): this.type =
-    // SI-5925: doesn't work with arguments that contains whitespaces
-    setCompilerSettings(options.split(" ").toList)
-
-  def setCompilerSettings(options: List[String]): this.type = {
-    val settings = new scala.tools.nsc.Settings(_ => ())
-    settings.copyInto(universe.settings)
-    this
-  }
-
-  def withCompilerSettings[T](options: String)(op: => T): T =
-    // SI-5925: doesn't work with arguments that contains whitespaces
-    withCompilerSettings(options.split(" ").toList)(op)
-
-  def withCompilerSettings[T](options: List[String])(op: => T): T = {
-    val old = options
-    setCompilerSettings(options)
-    try op
-    finally setCompilerSettings(old)
-  }
-}
diff --git a/src/compiler/scala/reflect/macros/runtime/TypeTags.scala b/src/compiler/scala/reflect/macros/runtime/TypeTags.scala
deleted file mode 100644
index 19b60159de..0000000000
--- a/src/compiler/scala/reflect/macros/runtime/TypeTags.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-package scala.reflect.macros
-package runtime
-
-trait TypeTags {
-  self: Context =>
-
-  def WeakTypeTag[T](tpe: Type): WeakTypeTag[T] = universe.WeakTypeTag[T](mirror, universe.FixedMirrorTypeCreator(mirror, tpe))
-  def TypeTag[T](tpe: Type): TypeTag[T] = universe.TypeTag[T](mirror, universe.FixedMirrorTypeCreator(mirror, tpe))
-}
diff --git a/src/compiler/scala/reflect/reify/Reifier.scala b/src/compiler/scala/reflect/reify/Reifier.scala
index 6f779be17d..f48fcd8ada 100644
--- a/src/compiler/scala/reflect/reify/Reifier.scala
+++ b/src/compiler/scala/reflect/reify/Reifier.scala
@@ -108,7 +108,7 @@ abstract class Reifier extends States
       // needs to be solved some day
       // maybe try `resetLocalAttrs` once the dust settles
       var importantSymbols = Set[Symbol](
-        NothingClass, AnyClass, SingletonClass, PredefModule, ScalaRunTimeModule, TypeCreatorClass, TreeCreatorClass, MirrorOfClass,
+        NothingClass, AnyClass, SingletonClass, PredefModule, ScalaRunTimeModule, TypeCreatorClass, TreeCreatorClass, MirrorClass,
         ApiUniverseClass, JavaUniverseClass, ReflectRuntimePackage, ReflectRuntimeCurrentMirror)
       importantSymbols ++= importantSymbols map (_.companionSymbol)
       importantSymbols ++= importantSymbols map (_.moduleClass)
diff --git a/src/compiler/scala/reflect/reify/utils/Extractors.scala b/src/compiler/scala/reflect/reify/utils/Extractors.scala
index 91cccaee99..b7206eda0e 100644
--- a/src/compiler/scala/reflect/reify/utils/Extractors.scala
+++ b/src/compiler/scala/reflect/reify/utils/Extractors.scala
@@ -19,7 +19,7 @@ trait Extractors {
   //         $treecreator1.super.<init>();
   //         ()
   //       };
-  //       def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Tree = {
+  //       def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Tree = {
   //         val $u: U = $m$untyped.universe;
   //         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
   //         $u.Apply($u.Select($u.Select($u.build.This($m.staticPackage("scala.collection.immutable").moduleClass), $u.newTermName("List")), $u.newTermName("apply")), List($u.Literal($u.Constant(1)), $u.Literal($u.Constant(2))))
@@ -32,7 +32,7 @@ trait Extractors {
   //         $typecreator1.super.<init>();
   //         ()
   //       };
-  //       def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Type = {
+  //       def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Type = {
   //         val $u: U = $m$untyped.universe;
   //         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
   //         $u.TypeRef($u.ThisType($m.staticPackage("scala.collection.immutable").moduleClass), $m.staticClass("scala.collection.immutable.List"), List($m.staticClass("scala.Int").toTypeConstructor))
@@ -81,7 +81,7 @@ trait Extractors {
         DefDef(NoMods,
           reifierName,
           List(TypeDef(Modifiers(PARAM), tparamu, List(), TypeBoundsTree(Ident(NothingClass), CompoundTypeTree(Template(List(Ident(reifierUniverse), Ident(SingletonClass)), emptyValDef, List()))))),
-          List(List(ValDef(Modifiers(PARAM), nme.MIRROR_UNTYPED, AppliedTypeTree(Ident(MirrorOfClass), List(Ident(tparamu))), EmptyTree))),
+          List(List(ValDef(Modifiers(PARAM), nme.MIRROR_UNTYPED, AppliedTypeTree(Ident(MirrorClass), List(Ident(tparamu))), EmptyTree))),
           reifierTpt, reifierBody))))
     Block(tpec, ApplyConstructor(Ident(tpec.name), List()))
   }
diff --git a/src/compiler/scala/reflect/reify/utils/NodePrinters.scala b/src/compiler/scala/reflect/reify/utils/NodePrinters.scala
index f0480e0699..000e500c69 100644
--- a/src/compiler/scala/reflect/reify/utils/NodePrinters.scala
+++ b/src/compiler/scala/reflect/reify/utils/NodePrinters.scala
@@ -75,7 +75,7 @@ trait NodePrinters {
 
       val printout = scala.collection.mutable.ListBuffer[String]();
       printout += universe.trim
-      if (mirrorIsUsed) printout += mirror.replace("MirrorOf[", "scala.reflect.api.MirrorOf[").trim
+      if (mirrorIsUsed) printout += mirror.replace("Mirror[", "scala.reflect.api.Mirror[").trim
       val imports = scala.collection.mutable.ListBuffer[String]();
       imports += nme.UNIVERSE_SHORT
       // if (buildIsUsed) imports += nme.build
diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala
index 6d3fd2e09e..5a2d5ef165 100644
--- a/src/compiler/scala/tools/nsc/CompilationUnits.scala
+++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala
@@ -23,7 +23,7 @@ trait CompilationUnits { self: Global =>
   /** One unit of compilation that has been submitted to the compiler.
     * It typically corresponds to a single file of source code.  It includes
     * error-reporting hooks.  */
-  class CompilationUnit(val source: SourceFile) {
+  class CompilationUnit(val source: SourceFile) extends CompilationUnitContextApi {
 
     /** the fresh name creator */
     var fresh: FreshNameCreator = new FreshNameCreator.Default
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 0fbd930ad7..708824ede1 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -1204,7 +1204,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
   /** A Run is a single execution of the compiler on a sets of units
    */
-  class Run {
+  class Run extends RunContextApi {
     /** Have been running into too many init order issues with Run
      *  during erroneous conditions.  Moved all these vals up to the
      *  top of the file so at least they're not trivially null.
diff --git a/src/compiler/scala/tools/reflect/FrontEnd.scala b/src/compiler/scala/tools/reflect/FrontEnd.scala
new file mode 100644
index 0000000000..f0d3d5973d
--- /dev/null
+++ b/src/compiler/scala/tools/reflect/FrontEnd.scala
@@ -0,0 +1,50 @@
+package scala.tools
+package reflect
+
+import scala.reflect.internal.util.Position
+
+trait FrontEnd {
+  object severity extends Enumeration
+  class Severity(val id: Int) extends severity.Value {
+    var count: Int = 0
+    override def toString() = this match {
+      case INFO => "INFO"
+      case WARNING => "WARNING"
+      case ERROR => "ERROR"
+      case _ => "<unknown>"
+    }
+  }
+  val INFO    = new Severity(0)
+  val WARNING = new Severity(1)
+  val ERROR   = new Severity(2)
+
+  def hasErrors   = ERROR.count > 0
+  def hasWarnings = WARNING.count > 0
+
+  case class Info(val pos: Position, val msg: String, val severity: Severity)
+  val infos = new scala.collection.mutable.LinkedHashSet[Info]
+
+  /** Handles incoming info */
+  def log(pos: Position, msg: String, severity: Severity) {
+    infos += new Info(pos, msg, severity)
+    severity.count += 1
+    display(infos.last)
+  }
+
+  /** Displays incoming info */
+  def display(info: Info): Unit
+
+  /** Services a request to drop into interactive mode */
+  def interactive(): Unit
+
+  /** Refreshes the UI */
+  def flush(): Unit = {}
+
+  /** Resets the reporter */
+  def reset(): Unit = {
+    INFO.count = 0
+    WARNING.count = 0
+    ERROR.count = 0
+    infos.clear()
+  }
+}
diff --git a/src/compiler/scala/tools/reflect/FrontEnds.scala b/src/compiler/scala/tools/reflect/FrontEnds.scala
deleted file mode 100644
index d0c3c1c774..0000000000
--- a/src/compiler/scala/tools/reflect/FrontEnds.scala
+++ /dev/null
@@ -1,88 +0,0 @@
-package scala.tools
-package reflect
-
-import scala.tools.nsc.reporters._
-import scala.tools.nsc.Settings
-import scala.reflect.ClassTag
-
-trait FrontEnds extends scala.reflect.api.FrontEnds {
-
-  type Position = scala.reflect.internal.util.Position
-
-  def mkConsoleFrontEnd(minSeverity: Int = 1): FrontEnd = {
-    val settings = new Settings()
-    if (minSeverity <= 0) settings.verbose.value = true
-    if (minSeverity > 1) settings.nowarn.value = true
-    wrapReporter(new ConsoleReporter(settings))
-  }
-
-  abstract class FrontEndToReporterProxy(val frontEnd: FrontEnd) extends AbstractReporter {
-    import frontEnd.{Severity => ApiSeverity}
-    val API_INFO = frontEnd.INFO
-    val API_WARNING = frontEnd.WARNING
-    val API_ERROR = frontEnd.ERROR
-
-    type NscSeverity = Severity
-    val NSC_INFO = INFO
-    val NSC_WARNING = WARNING
-    val NSC_ERROR = ERROR
-
-    def display(pos: Position, msg: String, nscSeverity: NscSeverity): Unit =
-      frontEnd.log(pos, msg, nscSeverity match {
-        case NSC_INFO => API_INFO
-        case NSC_WARNING => API_WARNING
-        case NSC_ERROR => API_ERROR
-      })
-
-    def displayPrompt(): Unit =
-      frontEnd.interactive()
-
-    override def flush(): Unit = {
-      super.flush()
-      frontEnd.flush()
-    }
-
-    override def reset(): Unit = {
-      super.reset()
-      frontEnd.reset()
-    }
-  }
-
-  def wrapFrontEnd(frontEnd: FrontEnd): Reporter = new FrontEndToReporterProxy(frontEnd) {
-    val settings = new Settings()
-    settings.verbose.value = true
-    settings.nowarn.value = false
-  }
-
-  class ReporterToFrontEndProxy(val reporter: Reporter) extends FrontEnd {
-    val API_INFO = INFO
-    val API_WARNING = WARNING
-    val API_ERROR = ERROR
-
-    override def hasErrors   = reporter.hasErrors
-    override def hasWarnings = reporter.hasWarnings
-
-    def display(info: Info): Unit = info.severity match {
-      case API_INFO => reporter.info(info.pos, info.msg, false)
-      case API_WARNING => reporter.warning(info.pos, info.msg)
-      case API_ERROR => reporter.error(info.pos, info.msg)
-    }
-
-    def interactive(): Unit = reporter match {
-      case reporter: AbstractReporter => reporter.displayPrompt()
-      case _ => // do nothing
-    }
-
-    override def flush(): Unit = {
-      super.flush()
-      reporter.flush()
-    }
-
-    override def reset(): Unit = {
-      super.reset()
-      reporter.reset()
-    }
-  }
-
-  def wrapReporter(reporter: Reporter): FrontEnd = new ReporterToFrontEndProxy(reporter)
-}
diff --git a/src/compiler/scala/tools/reflect/StdTags.scala b/src/compiler/scala/tools/reflect/StdTags.scala
index 94fd8e1fe8..a3bc9b9bd1 100644
--- a/src/compiler/scala/tools/reflect/StdTags.scala
+++ b/src/compiler/scala/tools/reflect/StdTags.scala
@@ -3,7 +3,7 @@ package reflect
 
 import java.lang.{Class => jClass}
 import scala.reflect.{ClassTag, classTag}
-import scala.reflect.api.{MirrorOf, TypeCreator, Universe => ApiUniverse}
+import scala.reflect.api.{Mirror, TypeCreator, Universe => ApiUniverse}
 
 // [Eugene++] Before 2.10 is released, I suggest we don't rely on automated type tag generation
 // sure, it's convenient, but then refactoring reflection / reification becomes a pain
@@ -11,13 +11,13 @@ import scala.reflect.api.{MirrorOf, TypeCreator, Universe => ApiUniverse}
 
 trait StdTags {
   val u: ApiUniverse with Singleton
-  val m: MirrorOf[u.type]
+  val m: Mirror[u.type]
 
   lazy val tagOfListOfString: u.TypeTag[List[String]] =
     u.TypeTag[List[String]](
       m,
       new TypeCreator {
-        def apply[U <: ApiUniverse with Singleton](m: MirrorOf[U]): U # Type = {
+        def apply[U <: ApiUniverse with Singleton](m: Mirror[U]): U # Type = {
           val u = m.universe
           val pre = u.ThisType(m.staticPackage("scala.collection.immutable").moduleClass.asInstanceOf[u.Symbol])
           u.TypeRef(pre, u.definitions.ListClass, List(u.definitions.StringClass.toTypeConstructor))
@@ -28,7 +28,7 @@ trait StdTags {
     u.TypeTag[T](
       m,
       new TypeCreator {
-        def apply[U <: ApiUniverse with Singleton](m: MirrorOf[U]): U # Type =
+        def apply[U <: ApiUniverse with Singleton](m: Mirror[U]): U # Type =
           m.staticClass(classTag[T].runtimeClass.getName).toTypeConstructor.asInstanceOf[U # Type]
       })
   lazy val tagOfInt = u.TypeTag.Int
diff --git a/src/compiler/scala/tools/reflect/ToolBox.scala b/src/compiler/scala/tools/reflect/ToolBox.scala
index f627699597..ab814b617d 100644
--- a/src/compiler/scala/tools/reflect/ToolBox.scala
+++ b/src/compiler/scala/tools/reflect/ToolBox.scala
@@ -15,6 +15,9 @@ trait ToolBox[U <: scala.reflect.api.Universe] {
    *
    *  Accumulates and displays warnings and errors, can drop to interactive mode (if supported).
    *  The latter can be useful to study the typechecker or to debug complex macros.
+   *
+   *  [[scala.tools.reflect]] provides two predefined front ends that can be created using
+   *  [[scala.tools.reflect.mkSilentFrontEnd]] and [[scala.tools.reflect.mkConsoleFrontEnd]].
    */
   def frontEnd: FrontEnd
 
diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
index 17d69cf94b..95135b84e0 100644
--- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
+++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
@@ -334,7 +334,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
         val errorFn: String => Unit = msg => frontEnd.log(scala.reflect.internal.util.NoPosition, msg, frontEnd.ERROR)
         val command = new CompilerCommand(arguments.toList, errorFn)
         command.settings.outputDirs setSingleOutput virtualDirectory
-        val instance = new ToolBoxGlobal(command.settings, new FrontEndToReporterProxy(frontEnd) { val settings = command.settings })
+        val instance = new ToolBoxGlobal(command.settings, frontEndToReporter(frontEnd, command.settings))
         if (frontEnd.hasErrors) {
           var msg = "reflective compilation has failed: cannot initialize the compiler: " + EOL + EOL
           msg += frontEnd.infos map (_.msg) mkString EOL
diff --git a/src/compiler/scala/tools/reflect/package.scala b/src/compiler/scala/tools/reflect/package.scala
index 901071d91a..8a1e3628e2 100644
--- a/src/compiler/scala/tools/reflect/package.scala
+++ b/src/compiler/scala/tools/reflect/package.scala
@@ -6,9 +6,12 @@
 package scala.tools
 
 import scala.reflect.api.JavaUniverse
+import scala.reflect.internal.util.Position
 import scala.language.implicitConversions
+import scala.tools.nsc.reporters._
+import scala.tools.nsc.Settings
 
-package object reflect extends FrontEnds {
+package object reflect {
   // [todo: can we generalize this?
   import scala.reflect.runtime.{universe => ru}
   implicit def ToolBox(mirror0: ru.Mirror): ToolBoxFactory[ru.type] =
@@ -17,9 +20,92 @@ package object reflect extends FrontEnds {
     }
 
   // todo. replace this with an implicit class, once the pesky warning is gone
+  // we don't provide `Eval` for trees, because it's unclear where to get an evaluation mirror from
   implicit def Eval[T](expr: JavaUniverse # Expr[T]): Eval[T] = new Eval[T](expr)
 
-  // we don't provide `Eval` for trees, because it's unclear where to get an evaluation mirror from
+  /** Creates a UI-less reporter that simply accumulates all the messages
+   */
+  def mkSilentFrontEnd(): FrontEnd = new FrontEnd {
+    def display(info: Info) {}
+    def interactive() {}
+  }
+
+  /** Creates a reporter that prints messages to the console according to the settings.
+   *
+   *  ``minSeverity'' determines minimum severity of the messages to be printed.
+   *  0 stands for INFO, 1 stands for WARNING and 2 stands for ERROR.
+   */
+  // todo. untangle warningsAsErrors from Reporters. I don't feel like moving this flag here!
+  def mkConsoleFrontEnd(minSeverity: Int = 1): FrontEnd = {
+    val settings = new Settings()
+    if (minSeverity <= 0) settings.verbose.value = true
+    if (minSeverity > 1) settings.nowarn.value = true
+    reporterToFrontEnd(new ConsoleReporter(settings))
+  }
+
+  private[reflect] def reporterToFrontEnd(reporter: Reporter): FrontEnd = new FrontEnd {
+    val API_INFO = INFO
+    val API_WARNING = WARNING
+    val API_ERROR = ERROR
+
+    override def hasErrors   = reporter.hasErrors
+    override def hasWarnings = reporter.hasWarnings
+
+    def display(info: Info): Unit = info.severity match {
+      case API_INFO => reporter.info(info.pos, info.msg, false)
+      case API_WARNING => reporter.warning(info.pos, info.msg)
+      case API_ERROR => reporter.error(info.pos, info.msg)
+    }
+
+    def interactive(): Unit = reporter match {
+      case reporter: AbstractReporter => reporter.displayPrompt()
+      case _ => // do nothing
+    }
+
+    override def flush(): Unit = {
+      super.flush()
+      reporter.flush()
+    }
+
+    override def reset(): Unit = {
+      super.reset()
+      reporter.reset()
+    }
+  }
+
+  private[reflect] def frontEndToReporter(frontEnd: FrontEnd, settings0: Settings): Reporter = new AbstractReporter {
+    val settings = settings0
+
+    import frontEnd.{Severity => ApiSeverity}
+    val API_INFO = frontEnd.INFO
+    val API_WARNING = frontEnd.WARNING
+    val API_ERROR = frontEnd.ERROR
+
+    type NscSeverity = Severity
+    val NSC_INFO = INFO
+    val NSC_WARNING = WARNING
+    val NSC_ERROR = ERROR
+
+    def display(pos: Position, msg: String, nscSeverity: NscSeverity): Unit =
+      frontEnd.log(pos, msg, nscSeverity match {
+        case NSC_INFO => API_INFO
+        case NSC_WARNING => API_WARNING
+        case NSC_ERROR => API_ERROR
+      })
+
+    def displayPrompt(): Unit =
+      frontEnd.interactive()
+
+    override def flush(): Unit = {
+      super.flush()
+      frontEnd.flush()
+    }
+
+    override def reset(): Unit = {
+      super.reset()
+      frontEnd.reset()
+    }
+  }
 }
 
 package reflect {
diff --git a/src/reflect/scala/reflect/api/BuildUtils.scala b/src/reflect/scala/reflect/api/BuildUtils.scala
index 2bb0cc3c76..b0de7f8d5a 100644
--- a/src/reflect/scala/reflect/api/BuildUtils.scala
+++ b/src/reflect/scala/reflect/api/BuildUtils.scala
@@ -4,7 +4,7 @@ package api
 /**
  * This is an internal implementation class.
  */
-trait BuildUtils { self: Universe =>
+private[reflect] trait BuildUtils { self: Universe =>
 
   val build: BuildApi
 
diff --git a/src/reflect/scala/reflect/api/Exprs.scala b/src/reflect/scala/reflect/api/Exprs.scala
index 65b0eb9301..b86f36420d 100644
--- a/src/reflect/scala/reflect/api/Exprs.scala
+++ b/src/reflect/scala/reflect/api/Exprs.scala
@@ -12,14 +12,18 @@ trait Exprs { self: Universe =>
 
   /** Expr wraps an expression tree and tags it with its type. */
   trait Expr[+T] extends Equals with Serializable {
+    /**
+     * Underlying mirror of this expr.
+     */
     val mirror: Mirror
+
     /**
      * Migrates the expression into another mirror, jumping into a different universe if necessary.
      *
      * This means that all symbolic references to classes/objects/packages in the expression
      * will be re-resolved within the new mirror (typically using that mirror's classloader).
      */
-    def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # Expr[T]
+    def in[U <: Universe with Singleton](otherMirror: scala.reflect.api.Mirror[U]): U # Expr[T]
 
     /**
      * The Scala syntax tree representing the wrapped expression.
@@ -91,13 +95,13 @@ trait Exprs { self: Universe =>
    * in which case the tree first needs to be wrapped in an expr.
    */
   object Expr {
-    def apply[T: WeakTypeTag](mirror: MirrorOf[self.type], treec: TreeCreator): Expr[T] = new ExprImpl[T](mirror.asInstanceOf[Mirror], treec)
+    def apply[T: WeakTypeTag](mirror: scala.reflect.api.Mirror[self.type], treec: TreeCreator): Expr[T] = new ExprImpl[T](mirror.asInstanceOf[Mirror], treec)
     def unapply[T](expr: Expr[T]): Option[Tree] = Some(expr.tree)
   }
 
   private class ExprImpl[+T: WeakTypeTag](val mirror: Mirror, val treec: TreeCreator) extends Expr[T] {
-    def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # Expr[T] = {
-      val otherMirror1 = otherMirror.asInstanceOf[MirrorOf[otherMirror.universe.type]]
+    def in[U <: Universe with Singleton](otherMirror: scala.reflect.api.Mirror[U]): U # Expr[T] = {
+      val otherMirror1 = otherMirror.asInstanceOf[scala.reflect.api.Mirror[otherMirror.universe.type]]
       val tag1 = (implicitly[WeakTypeTag[T]] in otherMirror).asInstanceOf[otherMirror.universe.WeakTypeTag[T]]
       otherMirror.universe.Expr[T](otherMirror1, treec)(tag1)
     }
diff --git a/src/reflect/scala/reflect/api/FrontEnds.scala b/src/reflect/scala/reflect/api/FrontEnds.scala
deleted file mode 100644
index 61ea227c47..0000000000
--- a/src/reflect/scala/reflect/api/FrontEnds.scala
+++ /dev/null
@@ -1,70 +0,0 @@
-package scala.reflect
-package api
-
-trait FrontEnds {
-
-  type Position >: Null
-
-  trait FrontEnd {
-    object severity extends Enumeration
-    class Severity(val id: Int) extends severity.Value {
-      var count: Int = 0
-      override def toString() = this match {
-        case INFO => "INFO"
-        case WARNING => "WARNING"
-        case ERROR => "ERROR"
-        case _ => "<unknown>"
-      }
-    }
-    val INFO    = new Severity(0)
-    val WARNING = new Severity(1)
-    val ERROR   = new Severity(2)
-
-    def hasErrors   = ERROR.count > 0
-    def hasWarnings = WARNING.count > 0
-
-    case class Info(val pos: Position, val msg: String, val severity: Severity)
-    val infos = new scala.collection.mutable.LinkedHashSet[Info]
-
-    /** Handles incoming info */
-    def log(pos: Position, msg: String, severity: Severity) {
-      infos += new Info(pos, msg, severity)
-      severity.count += 1
-      display(infos.last)
-    }
-
-    /** Displays incoming info */
-    def display(info: Info): Unit
-
-    /** Services a request to drop into interactive mode */
-    def interactive(): Unit
-
-    /** Refreshes the UI */
-    def flush(): Unit = {}
-
-    /** Resets the reporter */
-    def reset(): Unit = {
-      INFO.count = 0
-      WARNING.count = 0
-      ERROR.count = 0
-      infos.clear()
-    }
-  }
-
-  class SilentFrontEnd extends FrontEnd {
-    def display(info: Info) {}
-    def interactive() {}
-  }
-
-  /** Creates a UI-less reporter that simply accumulates all the messages
-   */
-  def mkSilentFrontEnd(): FrontEnd = new SilentFrontEnd()
-
-  /** Creates a reporter that prints messages to the console according to the settings.
-   *
-   *  ``minSeverity'' determines minimum severity of the messages to be printed.
-   *  0 stands for INFO, 1 stands for WARNING and 2 stands for ERROR.
-   */
-  // todo. untangle warningsAsErrors from Reporters. I don't feel like moving this flag here!
-  def mkConsoleFrontEnd(minSeverity: Int = 1): FrontEnd
-}
diff --git a/src/reflect/scala/reflect/api/JavaUniverse.scala b/src/reflect/scala/reflect/api/JavaUniverse.scala
index ba38381561..cc703e833d 100644
--- a/src/reflect/scala/reflect/api/JavaUniverse.scala
+++ b/src/reflect/scala/reflect/api/JavaUniverse.scala
@@ -7,7 +7,7 @@ trait JavaUniverse extends Universe with Mirrors { self =>
 
   override type Mirror >: Null <: JavaMirror
 
-  trait JavaMirror extends MirrorOf[self.type] with RuntimeMirror {
+  trait JavaMirror extends scala.reflect.api.Mirror[self.type] with RuntimeMirror {
     val classLoader: ClassLoader
     override def toString = s"JavaMirror with ${runtime.ReflectionUtils.show(classLoader)}"
   }
@@ -23,7 +23,7 @@ trait JavaUniverse extends Universe with Mirrors { self =>
 
   override def manifestToTypeTag[T](mirror0: Any, manifest: Manifest[T]): Universe # TypeTag[T] =
     TypeTag(mirror0.asInstanceOf[Mirror], new TypeCreator {
-      def apply[U <: Universe with Singleton](mirror: MirrorOf[U]): U # Type = {
+      def apply[U <: Universe with Singleton](mirror: scala.reflect.api.Mirror[U]): U # Type = {
         mirror.universe match {
           case ju: JavaUniverse =>
             val jm = mirror.asInstanceOf[ju.Mirror]
diff --git a/src/reflect/scala/reflect/api/MirrorOf.scala b/src/reflect/scala/reflect/api/Mirror.scala
index cd5641e692..2de0d7120e 100644
--- a/src/reflect/scala/reflect/api/MirrorOf.scala
+++ b/src/reflect/scala/reflect/api/Mirror.scala
@@ -8,13 +8,13 @@ package api
  *
  * This is defined outside the reflection universe cake pattern implementation
  * so that it can be referenced from outside. For example TypeCreator and TreeCreator
- * reference MirrorOf and also need to be defined outside the cake as they are
+ * reference Mirror and also need to be defined outside the cake as they are
  * used by type tags, which can be migrated between different universes and consequently
  * cannot be bound to a fixed one.
  *
  * @see [[Mirrors]]
  */
-abstract class MirrorOf[U <: Universe with Singleton] {
+abstract class Mirror[U <: Universe with Singleton] {
   /** The universe this mirror belongs to. */
   val universe: U
 
diff --git a/src/reflect/scala/reflect/api/Mirrors.scala b/src/reflect/scala/reflect/api/Mirrors.scala
index c935533027..bff899daa4 100644
--- a/src/reflect/scala/reflect/api/Mirrors.scala
+++ b/src/reflect/scala/reflect/api/Mirrors.scala
@@ -11,8 +11,12 @@ package api
  */
 trait Mirrors { self: Universe =>
 
-  /** The base type of all mirrors of this universe */
-  type Mirror >: Null <: MirrorOf[self.type]
+  /** The base type of all mirrors of this universe.
+   *
+   *  This abstract type conforms the base interface for all mirrors defined in [[scala.reflect.api.Mirror]]
+   *  and is gradually refined in specific universes (e.g. `Mirror` of a [[scala.reflect.api.JavaUniverse]] is capable of reflection).
+   */
+  type Mirror >: Null <: scala.reflect.api.Mirror[self.type]
 
   /** The root mirror of this universe. This mirror contains standard Scala classes and types such as `Any`, `AnyRef`, `AnyVal`,
    *  `Nothing`, `Null`, and all classes loaded from scala-library, which are shared across all mirrors within the enclosing universe.
@@ -239,7 +243,7 @@ trait Mirrors { self: Universe =>
   }
 
   /** A mirror that reflects instances and static classes */
-  trait ReflectiveMirror extends MirrorOf[Mirrors.this.type] {
+  trait ReflectiveMirror extends scala.reflect.api.Mirror[Mirrors.this.type] {
 
     /** A reflective mirror for the given object.
      *
diff --git a/src/reflect/scala/reflect/api/Position.scala b/src/reflect/scala/reflect/api/Position.scala
new file mode 100644
index 0000000000..9c63e4becf
--- /dev/null
+++ b/src/reflect/scala/reflect/api/Position.scala
@@ -0,0 +1,167 @@
+package scala.reflect
+package api
+
+/** The Position class and its subclasses represent positions of ASTs and symbols.
+ *  Except for NoPosition and FakePos, every position refers to a SourceFile
+ *  and to an offset in the sourcefile (its `point`). For batch compilation,
+ *  that's all. For interactive IDE's there are also RangePositions
+ *  and TransparentPositions. A RangePosition indicates a start and an end
+ *  in addition to its point. TransparentPositions are a subclass of RangePositions.
+ *  Range positions that are not transparent are called opaque.
+ *  Trees with RangePositions need to satisfy the following invariants.
+ *
+ *  INV1: A tree with an offset position never contains a child
+ *        with a range position
+ *  INV2: If the child of a tree with a range position also has a range position,
+ *        then the child's range is contained in the parent's range.
+ *  INV3: Opaque range positions of children of the same node are non-overlapping
+ *        (this means their overlap is at most a single point).
+ *
+ *  The following tests are useful on positions:
+ *
+ *  pos.isDefined     true if position is not a NoPosition nor a FakePosition
+ *  pos.isRange       true if position is a range
+ *  pos.isOpaqueRange true if position is an opaque range
+ *
+ *  The following accessor methods are provided:
+ *
+ *  pos.source        The source file of the position, which must be defined
+ *  pos.point         The offset of the position's point, which must be defined
+ *  pos.start         The start of the position, which must be a range
+ *  pos.end           The end of the position, which must be a range
+ *
+ *  There are also convenience methods, such as
+ *
+ *  pos.startOrPoint
+ *  pos.endOrPoint
+ *  pos.pointOrElse(default)
+ *
+ *  These are less strict about the kind of position on which they can be applied.
+ *
+ *  The following conversion methods are often used:
+ *
+ *  pos.focus           converts a range position to an offset position, keeping its point;
+ *                      returns all other positions unchanged.
+ *  pos.makeTransparent converts an opaque range position into a transparent one.
+ *                      returns all other positions unchanged.
+ */
+trait Position extends Attachments {
+
+  type Pos >: Null <: Position
+
+  /** Java file corresponding to the source file of this position.
+   *
+   *  The return type is [[scala.reflect.io.AbstractFile]], which belongs to an experimental part of Scala reflection.
+   *  It should not be used unless you know what you are doing. In subsequent releases, this API will be refined
+   *  and exposed as a part of scala.reflect.api.
+   */
+  def source: scala.reflect.internal.util.SourceFile
+
+  /** Is this position neither a NoPosition nor a FakePosition?
+   *  If isDefined is true, offset and source are both defined.
+   */
+  def isDefined: Boolean
+
+  /** Is this position a range position? */
+  def isRange: Boolean
+
+  /** Is this position a transparent position? */
+  def isTransparent: Boolean
+
+  /** Is this position a non-transparent range position? */
+  def isOpaqueRange: Boolean
+
+  /** if opaque range, make this position transparent */
+  def makeTransparent: Pos
+
+  /** The start of the position's range, error if not a range position */
+  def start: Int
+
+  /** The start of the position's range, or point if not a range position */
+  def startOrPoint: Int
+
+  /**  The point (where the ^ is) of the position */
+  def point: Int
+
+  /**  The point (where the ^ is) of the position, or else `default` if undefined */
+  def pointOrElse(default: Int): Int
+
+  /** The end of the position's range, error if not a range position */
+  def end: Int
+
+  /** The end of the position's range, or point if not a range position */
+  def endOrPoint: Int
+
+  /** The same position with a different start value (if a range) */
+  def withStart(off: Int): Pos
+
+  /** The same position with a different end value (if a range) */
+  def withEnd(off: Int): Pos
+
+  /** The same position with a different point value (if a range or offset) */
+  def withPoint(off: Int): Pos
+
+  /** If this is a range, the union with the other range, with the point of this position.
+   *  Otherwise, this position
+   */
+  def union(pos: Pos): Pos
+
+  /** If this is a range position, the offset position of its point.
+   *  Otherwise the position itself
+   */
+  def focus: Pos
+
+  /** If this is a range position, the offset position of its start.
+   *  Otherwise the position itself
+   */
+  def focusStart: Pos
+
+  /** If this is a range position, the offset position of its end.
+   *  Otherwise the position itself
+   */
+  def focusEnd: Pos
+
+  /** Does this position include the given position `pos`.
+   *  This holds if `this` is a range position and its range [start..end]
+   *  is the same or covers the range of the given position, which may or may not be a range position.
+   */
+  def includes(pos: Pos): Boolean
+
+  /** Does this position properly include the given position `pos` ("properly" meaning their
+   *  ranges are not the same)?
+   */
+  def properlyIncludes(pos: Pos): Boolean
+
+  /** Does this position precede that position?
+   *  This holds if both positions are defined and the end point of this position
+   *  is not larger than the start point of the given position.
+   */
+  def precedes(pos: Pos): Boolean
+
+  /** Does this position properly precede the given position `pos` ("properly" meaning their ranges
+   *  do not share a common point).
+   */
+  def properlyPrecedes(pos: Pos): Boolean
+
+  /** Does this position overlap with that position?
+   *  This holds if both positions are ranges and there is an interval of
+   *  non-zero length that is shared by both position ranges.
+   */
+  def overlaps(pos: Pos): Boolean
+
+  /** Does this position cover the same range as that position?
+   *  Holds only if both position are ranges
+   */
+  def sameRange(pos: Pos): Boolean
+
+  def line: Int
+
+  def column: Int
+
+  /** Convert this to a position around `point` that spans a single source line */
+  def toSingleLine: Pos
+
+  def lineContent: String
+
+  def show: String
+}
diff --git a/src/reflect/scala/reflect/api/Positions.scala b/src/reflect/scala/reflect/api/Positions.scala
index 0eddc88fc4..5c530e7e70 100644
--- a/src/reflect/scala/reflect/api/Positions.scala
+++ b/src/reflect/scala/reflect/api/Positions.scala
@@ -10,7 +10,7 @@ trait Positions {
   self: Universe =>
 
   /** .. */
-  type Position >: Null <: PositionApi { type Pos = Position }
+  type Position >: Null <: scala.reflect.api.Position { type Pos = Position }
 
   /** A tag that preserves the identity of the `Position` abstract type from erasure.
    *  Can be used for pattern matching, instance tests, serialization and likes.
@@ -38,168 +38,3 @@ trait Positions {
    */
   def wrappingPos(trees: List[Tree]): Position
 }
-
-/** The Position class and its subclasses represent positions of ASTs and symbols.
- *  Except for NoPosition and FakePos, every position refers to a SourceFile
- *  and to an offset in the sourcefile (its `point`). For batch compilation,
- *  that's all. For interactive IDE's there are also RangePositions
- *  and TransparentPositions. A RangePosition indicates a start and an end
- *  in addition to its point. TransparentPositions are a subclass of RangePositions.
- *  Range positions that are not transparent are called opaque.
- *  Trees with RangePositions need to satisfy the following invariants.
- *
- *  INV1: A tree with an offset position never contains a child
- *        with a range position
- *  INV2: If the child of a tree with a range position also has a range position,
- *        then the child's range is contained in the parent's range.
- *  INV3: Opaque range positions of children of the same node are non-overlapping
- *        (this means their overlap is at most a single point).
- *
- *  The following tests are useful on positions:
- *
- *  pos.isDefined     true if position is not a NoPosition nor a FakePosition
- *  pos.isRange       true if position is a range
- *  pos.isOpaqueRange true if position is an opaque range
- *
- *  The following accessor methods are provided:
- *
- *  pos.source        The source file of the position, which must be defined
- *  pos.point         The offset of the position's point, which must be defined
- *  pos.start         The start of the position, which must be a range
- *  pos.end           The end of the position, which must be a range
- *
- *  There are also convenience methods, such as
- *
- *  pos.startOrPoint
- *  pos.endOrPoint
- *  pos.pointOrElse(default)
- *
- *  These are less strict about the kind of position on which they can be applied.
- *
- *  The following conversion methods are often used:
- *
- *  pos.focus           converts a range position to an offset position, keeping its point;
- *                      returns all other positions unchanged.
- *  pos.makeTransparent converts an opaque range position into a transparent one.
- *                      returns all other positions unchanged.
- */
-trait PositionApi extends Attachments {
-
-  type Pos >: Null <: PositionApi
-
-  /** Java file corresponding to the source file of this position.
-   */
-  def fileInfo: java.io.File
-
-  /** Content of the source file that contains this position.
-   */
-  def fileContent: Array[Char]
-
-  /** Is this position neither a NoPosition nor a FakePosition?
-   *  If isDefined is true, offset and source are both defined.
-   */
-  def isDefined: Boolean
-
-  /** Is this position a range position? */
-  def isRange: Boolean
-
-  /** Is this position a transparent position? */
-  def isTransparent: Boolean
-
-  /** Is this position a non-transparent range position? */
-  def isOpaqueRange: Boolean
-
-  /** if opaque range, make this position transparent */
-  def makeTransparent: Pos
-
-  /** The start of the position's range, error if not a range position */
-  def start: Int
-
-  /** The start of the position's range, or point if not a range position */
-  def startOrPoint: Int
-
-  /**  The point (where the ^ is) of the position */
-  def point: Int
-
-  /**  The point (where the ^ is) of the position, or else `default` if undefined */
-  def pointOrElse(default: Int): Int
-
-  /** The end of the position's range, error if not a range position */
-  def end: Int
-
-  /** The end of the position's range, or point if not a range position */
-  def endOrPoint: Int
-
-  /** The same position with a different start value (if a range) */
-  def withStart(off: Int): Pos
-
-  /** The same position with a different end value (if a range) */
-  def withEnd(off: Int): Pos
-
-  /** The same position with a different point value (if a range or offset) */
-  def withPoint(off: Int): Pos
-
-  /** If this is a range, the union with the other range, with the point of this position.
-   *  Otherwise, this position
-   */
-  def union(pos: Pos): Pos
-
-  /** If this is a range position, the offset position of its point.
-   *  Otherwise the position itself
-   */
-  def focus: Pos
-
-  /** If this is a range position, the offset position of its start.
-   *  Otherwise the position itself
-   */
-  def focusStart: Pos
-
-  /** If this is a range position, the offset position of its end.
-   *  Otherwise the position itself
-   */
-  def focusEnd: Pos
-
-  /** Does this position include the given position `pos`.
-   *  This holds if `this` is a range position and its range [start..end]
-   *  is the same or covers the range of the given position, which may or may not be a range position.
-   */
-  def includes(pos: Pos): Boolean
-
-  /** Does this position properly include the given position `pos` ("properly" meaning their
-   *  ranges are not the same)?
-   */
-  def properlyIncludes(pos: Pos): Boolean
-
-  /** Does this position precede that position?
-   *  This holds if both positions are defined and the end point of this position
-   *  is not larger than the start point of the given position.
-   */
-  def precedes(pos: Pos): Boolean
-
-  /** Does this position properly precede the given position `pos` ("properly" meaning their ranges
-   *  do not share a common point).
-   */
-  def properlyPrecedes(pos: Pos): Boolean
-
-  /** Does this position overlap with that position?
-   *  This holds if both positions are ranges and there is an interval of
-   *  non-zero length that is shared by both position ranges.
-   */
-  def overlaps(pos: Pos): Boolean
-
-  /** Does this position cover the same range as that position?
-   *  Holds only if both position are ranges
-   */
-  def sameRange(pos: Pos): Boolean
-
-  def line: Int
-
-  def column: Int
-
-  /** Convert this to a position around `point` that spans a single source line */
-  def toSingleLine: Pos
-
-  def lineContent: String
-
-  def show: String
-}
diff --git a/src/reflect/scala/reflect/api/Symbols.scala b/src/reflect/scala/reflect/api/Symbols.scala
index d8f955ddf3..8b24b953ae 100644
--- a/src/reflect/scala/reflect/api/Symbols.scala
+++ b/src/reflect/scala/reflect/api/Symbols.scala
@@ -86,10 +86,10 @@ trait Symbols { self: Universe =>
      *  that directly contains the current symbol's definition.
      *  The `NoSymbol` symbol does not have an owner, and calling this method
      *  on one causes an internal error.
-     *  The owner of the Scala root class [[scala.reflect.api.MirrorOf.RootClass]]
-     *  and the Scala root object [[scala.reflect.api.MirrorOf.RootPackage]] is `NoSymbol`.
+     *  The owner of the Scala root class [[scala.reflect.api.Mirror.RootClass]]
+     *  and the Scala root object [[scala.reflect.api.Mirror.RootPackage]] is `NoSymbol`.
      *  Every other symbol has a chain of owners that ends in
-     *  [[scala.reflect.api.MirrorOf.RootClass]].
+     *  [[scala.reflect.api.Mirror.RootClass]].
      */
     def owner: Symbol
 
@@ -209,6 +209,10 @@ trait Symbols { self: Universe =>
 
     /** Source file if this symbol is created during this compilation run,
      *  or a class file if this symbol is loaded from a *.class or *.jar.
+     *
+     *  The return type is [[scala.reflect.io.AbstractFile]], which belongs to an experimental part of Scala reflection.
+     *  It should not be used unless you know what you are doing. In subsequent releases, this API will be refined
+     *  and exposed as a part of scala.reflect.api.
      */
     def associatedFile: scala.reflect.io.AbstractFile
 
diff --git a/src/reflect/scala/reflect/api/TreeCreator.scala b/src/reflect/scala/reflect/api/TreeCreator.scala
index 0c8701775c..a8e8ae1b58 100644
--- a/src/reflect/scala/reflect/api/TreeCreator.scala
+++ b/src/reflect/scala/reflect/api/TreeCreator.scala
@@ -22,5 +22,5 @@ package api
  * `TreeCreator` can't have a functional type, so it's implemented as class with an apply method.
  */
 abstract class TreeCreator {
-  def apply[U <: Universe with Singleton](m: MirrorOf[U]): U # Tree
+  def apply[U <: Universe with Singleton](m: scala.reflect.api.Mirror[U]): U # Tree
 }
diff --git a/src/reflect/scala/reflect/api/TypeCreator.scala b/src/reflect/scala/reflect/api/TypeCreator.scala
index cc6d38c548..2b3ef4320b 100644
--- a/src/reflect/scala/reflect/api/TypeCreator.scala
+++ b/src/reflect/scala/reflect/api/TypeCreator.scala
@@ -22,5 +22,5 @@ package api
  * `TypeCreator` can't have a functional type, so it's implemented as class with an apply method.
  */
 abstract class TypeCreator {
-  def apply[U <: Universe with Singleton](m: MirrorOf[U]): U # Type
+  def apply[U <: Universe with Singleton](m: scala.reflect.api.Mirror[U]): U # Type
 }
diff --git a/src/reflect/scala/reflect/api/TypeTags.scala b/src/reflect/scala/reflect/api/TypeTags.scala
index a7e58d2bcb..fc3f067a96 100644
--- a/src/reflect/scala/reflect/api/TypeTags.scala
+++ b/src/reflect/scala/reflect/api/TypeTags.scala
@@ -154,19 +154,17 @@ trait TypeTags { self: Universe =>
   @annotation.implicitNotFound(msg = "No WeakTypeTag available for ${T}")
   trait WeakTypeTag[T] extends Equals with Serializable {
     /**
-     * Mirror corresponding to the universe of this WeakTypeTag.
+     * Underlying mirror of this type tag.
      */
     val mirror: Mirror
+
     /**
-     * Migrates type tag to another universe.
-     *
-     * Type tags are path dependent on their universe. This methods allows migration
-     * given the mirror corresponding to the target universe.
+     * Migrates the expression into another mirror, jumping into a different universe if necessary.
      *
      * Migration means that all symbolic references to classes/objects/packages in the expression
      * will be re-resolved within the new mirror (typically using that mirror's classloader).
      */
-    def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # WeakTypeTag[T]
+    def in[U <: Universe with Singleton](otherMirror: scala.reflect.api.Mirror[U]): U # WeakTypeTag[T]
 
     /**
      * Reflective representation of type T.
@@ -201,7 +199,7 @@ trait TypeTags { self: Universe =>
     val Null    : WeakTypeTag[scala.Null]       = TypeTag.Null
 
 
-    def apply[T](mirror1: MirrorOf[self.type], tpec1: TypeCreator): WeakTypeTag[T] =
+    def apply[T](mirror1: scala.reflect.api.Mirror[self.type], tpec1: TypeCreator): WeakTypeTag[T] =
       tpec1(mirror1) match {
         case ByteTpe    => WeakTypeTag.Byte.asInstanceOf[WeakTypeTag[T]]
         case ShortTpe   => WeakTypeTag.Short.asInstanceOf[WeakTypeTag[T]]
@@ -226,8 +224,8 @@ trait TypeTags { self: Universe =>
 
   private class WeakTypeTagImpl[T](val mirror: Mirror, val tpec: TypeCreator) extends WeakTypeTag[T] {
     lazy val tpe: Type = tpec(mirror)
-    def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # WeakTypeTag[T] = {
-      val otherMirror1 = otherMirror.asInstanceOf[MirrorOf[otherMirror.universe.type]]
+    def in[U <: Universe with Singleton](otherMirror: scala.reflect.api.Mirror[U]): U # WeakTypeTag[T] = {
+      val otherMirror1 = otherMirror.asInstanceOf[scala.reflect.api.Mirror[otherMirror.universe.type]]
       otherMirror.universe.WeakTypeTag[T](otherMirror1, tpec)
     }
     private def writeReplace(): AnyRef = new SerializedTypeTag(tpec, concrete = false)
@@ -245,7 +243,7 @@ trait TypeTags { self: Universe =>
     /**
      * @inheritdoc
      */
-    override def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # TypeTag[T]
+    override def in[U <: Universe with Singleton](otherMirror: scala.reflect.api.Mirror[U]): U # TypeTag[T]
 
     // case class accessories
     override def canEqual(x: Any) = x.isInstanceOf[TypeTag[_]]
@@ -271,7 +269,7 @@ trait TypeTags { self: Universe =>
     val Nothing: TypeTag[scala.Nothing]    = new PredefTypeTag[scala.Nothing]    (NothingTpe, _.TypeTag.Nothing)
     val Null:    TypeTag[scala.Null]       = new PredefTypeTag[scala.Null]       (NullTpe,    _.TypeTag.Null)
 
-    def apply[T](mirror1: MirrorOf[self.type], tpec1: TypeCreator): TypeTag[T] =
+    def apply[T](mirror1: scala.reflect.api.Mirror[self.type], tpec1: TypeCreator): TypeTag[T] =
       tpec1(mirror1) match {
         case ByteTpe    => TypeTag.Byte.asInstanceOf[TypeTag[T]]
         case ShortTpe   => TypeTag.Short.asInstanceOf[TypeTag[T]]
@@ -295,15 +293,15 @@ trait TypeTags { self: Universe =>
   }
 
   private class TypeTagImpl[T](mirror: Mirror, tpec: TypeCreator) extends WeakTypeTagImpl[T](mirror, tpec) with TypeTag[T] {
-    override def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # TypeTag[T] = {
-      val otherMirror1 = otherMirror.asInstanceOf[MirrorOf[otherMirror.universe.type]]
+    override def in[U <: Universe with Singleton](otherMirror: scala.reflect.api.Mirror[U]): U # TypeTag[T] = {
+      val otherMirror1 = otherMirror.asInstanceOf[scala.reflect.api.Mirror[otherMirror.universe.type]]
       otherMirror.universe.TypeTag[T](otherMirror1, tpec)
     }
     private def writeReplace(): AnyRef = new SerializedTypeTag(tpec, concrete = true)
   }
 
   private class PredefTypeCreator[T](copyIn: Universe => Universe#TypeTag[T]) extends TypeCreator {
-    def apply[U <: Universe with Singleton](m: MirrorOf[U]): U # Type = {
+    def apply[U <: Universe with Singleton](m: scala.reflect.api.Mirror[U]): U # Type = {
       copyIn(m.universe).asInstanceOf[U # TypeTag[T]].tpe
     }
   }
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index b607f8cad9..6cdca3d7f8 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -517,7 +517,7 @@ trait Definitions extends api.StandardDefinitions {
          def ApiUniverseReify      = if (ApiUniverseClass != NoSymbol) getMemberMethod(ApiUniverseClass, nme.reify) else NoSymbol
     lazy val JavaUniverseClass     = getClassIfDefined("scala.reflect.api.JavaUniverse") // defined in scala-reflect.jar, so we need to be careful
 
-    lazy val MirrorOfClass         = getClassIfDefined("scala.reflect.api.MirrorOf") // defined in scala-reflect.jar, so we need to be careful
+    lazy val MirrorClass           = getClassIfDefined("scala.reflect.api.Mirror") // defined in scala-reflect.jar, so we need to be careful
 
     lazy val TypeCreatorClass      = getClassIfDefined("scala.reflect.api.TypeCreator") // defined in scala-reflect.jar, so we need to be careful
     lazy val TreeCreatorClass      = getClassIfDefined("scala.reflect.api.TreeCreator") // defined in scala-reflect.jar, so we need to be careful
diff --git a/src/reflect/scala/reflect/internal/Mirrors.scala b/src/reflect/scala/reflect/internal/Mirrors.scala
index 4836db5db0..019cf7f908 100644
--- a/src/reflect/scala/reflect/internal/Mirrors.scala
+++ b/src/reflect/scala/reflect/internal/Mirrors.scala
@@ -19,7 +19,7 @@ trait Mirrors extends api.Mirrors {
   // if there are any symbols created by that mirror
   trait RootSymbol extends Symbol { def mirror: Mirror }
 
-  abstract class RootsBase(rootOwner: Symbol) extends MirrorOf[Mirrors.this.type] { thisMirror =>
+  abstract class RootsBase(rootOwner: Symbol) extends scala.reflect.api.Mirror[Mirrors.this.type] { thisMirror =>
 
     protected[scala] def rootLoader: LazyType
 
diff --git a/src/reflect/scala/reflect/internal/Printers.scala b/src/reflect/scala/reflect/internal/Printers.scala
index 4c423e0bc2..cb8dc4b197 100644
--- a/src/reflect/scala/reflect/internal/Printers.scala
+++ b/src/reflect/scala/reflect/internal/Printers.scala
@@ -580,7 +580,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
           else print(sym.name)
           if (printIds) print("#", sym.id)
           if (printKinds) print("#", sym.abbreviatedKindString)
-          if (printMirrors) print("%M", footnotes.put[MirrorOf[_]](mirrorThatLoaded(sym)))
+          if (printMirrors) print("%M", footnotes.put[scala.reflect.api.Mirror[_]](mirrorThatLoaded(sym)))
         case NoType =>
           print("NoType")
         case NoPrefix =>
@@ -609,7 +609,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
       if (depth == 0 && !printingFootnotes) {
         printingFootnotes = true
         footnotes.print[Type](this)
-        footnotes.print[MirrorOf[_]](this)
+        footnotes.print[scala.reflect.api.Mirror[_]](this)
         printingFootnotes = false
       }
     }
diff --git a/src/reflect/scala/reflect/internal/StdCreators.scala b/src/reflect/scala/reflect/internal/StdCreators.scala
index eba583d4b5..5e5e4f9043 100644
--- a/src/reflect/scala/reflect/internal/StdCreators.scala
+++ b/src/reflect/scala/reflect/internal/StdCreators.scala
@@ -7,14 +7,14 @@ import scala.reflect.api.{Universe => ApiUniverse}
 trait StdCreators {
   self: SymbolTable =>
 
-  case class FixedMirrorTreeCreator(mirror: MirrorOf[StdCreators.this.type], tree: Tree) extends TreeCreator {
-    def apply[U <: ApiUniverse with Singleton](m: MirrorOf[U]): U # Tree =
+  case class FixedMirrorTreeCreator(mirror: scala.reflect.api.Mirror[StdCreators.this.type], tree: Tree) extends TreeCreator {
+    def apply[U <: ApiUniverse with Singleton](m: scala.reflect.api.Mirror[U]): U # Tree =
       if (m eq mirror) tree.asInstanceOf[U # Tree]
       else throw new IllegalArgumentException(s"Expr defined in $mirror cannot be migrated to other mirrors.")
   }
 
-  case class FixedMirrorTypeCreator(mirror: MirrorOf[StdCreators.this.type], tpe: Type) extends TypeCreator {
-    def apply[U <: ApiUniverse with Singleton](m: MirrorOf[U]): U # Type =
+  case class FixedMirrorTypeCreator(mirror: scala.reflect.api.Mirror[StdCreators.this.type], tpe: Type) extends TypeCreator {
+    def apply[U <: ApiUniverse with Singleton](m: scala.reflect.api.Mirror[U]): U # Type =
       if (m eq mirror) tpe.asInstanceOf[U # Type]
       else throw new IllegalArgumentException(s"Type tag defined in $mirror cannot be migrated to other mirrors.")
   }
diff --git a/src/reflect/scala/reflect/internal/package.scala b/src/reflect/scala/reflect/internal/package.scala
deleted file mode 100644
index 63568f6a6b..0000000000
--- a/src/reflect/scala/reflect/internal/package.scala
+++ /dev/null
@@ -1,6 +0,0 @@
-package scala.reflect
-
-package object internal {
-
-  type MirrorOf[U <: scala.reflect.api.Universe with Singleton] = scala.reflect.api.MirrorOf[U]
-}
diff --git a/src/reflect/scala/reflect/internal/util/Position.scala b/src/reflect/scala/reflect/internal/util/Position.scala
index 1621fb84d4..151a64daff 100644
--- a/src/reflect/scala/reflect/internal/util/Position.scala
+++ b/src/reflect/scala/reflect/internal/util/Position.scala
@@ -8,7 +8,6 @@ package scala.reflect.internal.util
 
 import scala.reflect.ClassTag
 import scala.reflect.api.Attachments
-import scala.reflect.api.PositionApi
 
 object Position {
   val tabInc = 8
@@ -36,7 +35,7 @@ object Position {
   }
 }
 
-abstract class Position extends PositionApi { self =>
+abstract class Position extends scala.reflect.api.Position { self =>
 
   type Pos = Position
 
@@ -44,16 +43,6 @@ abstract class Position extends PositionApi { self =>
 
   def withPos(newPos: Position): Attachments { type Pos = self.Pos } = newPos
 
-  /** Java file corresponding to the source file of this position.
-   */
-  // necessary for conformance with scala.reflect.api.Position
-  def fileInfo: java.io.File = source.file.file
-
-  /** Contents of the source file that contains this position.
-   */
-  // necessary for conformance with scala.reflect.api.Position
-  def fileContent: Array[Char] = source.content
-
   /** An optional value containing the source file referred to by this position, or
    *  None if not defined.
    */
diff --git a/src/reflect/scala/reflect/macros/Aliases.scala b/src/reflect/scala/reflect/macros/Aliases.scala
index eff7f34b02..754335d50d 100644
--- a/src/reflect/scala/reflect/macros/Aliases.scala
+++ b/src/reflect/scala/reflect/macros/Aliases.scala
@@ -10,17 +10,22 @@ trait Aliases {
   type TermName = universe.TermName
   type TypeName = universe.TypeName
   type Tree = universe.Tree
-  // type Position = universe.Position
+  type Position = universe.Position
   type Scope = universe.Scope
   type Modifiers = universe.Modifiers
+  type Run = universe.Run
+  type CompilationUnit = universe.CompilationUnit
 
   type Expr[+T] = universe.Expr[T]
   val Expr = universe.Expr
+  def Expr[T: WeakTypeTag](tree: Tree): Expr[T]
 
   type WeakTypeTag[T] = universe.WeakTypeTag[T]
   type TypeTag[T] = universe.TypeTag[T]
   val WeakTypeTag = universe.WeakTypeTag
   val TypeTag = universe.TypeTag
+  def WeakTypeTag[T](tpe: Type): WeakTypeTag[T]
+  def TypeTag[T](tpe: Type): TypeTag[T]
   def weakTypeTag[T](implicit attag: WeakTypeTag[T]) = attag
   def typeTag[T](implicit ttag: TypeTag[T]) = ttag
   def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type = attag.tpe
diff --git a/src/reflect/scala/reflect/macros/CapturedVariables.scala b/src/reflect/scala/reflect/macros/CapturedVariables.scala
deleted file mode 100644
index 60ed6f5e7b..0000000000
--- a/src/reflect/scala/reflect/macros/CapturedVariables.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-package scala.reflect
-package macros
-
-trait CapturedVariables {
-  self: Context =>
-
-  import mirror._
-
-  /** Mark a variable as captured; i.e. force boxing in a *Ref type.
-   */
-  def captureVariable(vble: Symbol): Unit
-
-  /** Mark given identifier as a reference to a captured variable itself
-   *  suppressing dereferencing with the `elem` field.
-   */
-  def referenceCapturedVariable(vble: Symbol): Tree
-
-  /** Convert type of a captured variable to *Ref type.
-   */
-  def capturedVariableType(vble: Symbol): Type
-}
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/macros/Context.scala b/src/reflect/scala/reflect/macros/Context.scala
index 37c8f9057e..7a365ed37b 100644
--- a/src/reflect/scala/reflect/macros/Context.scala
+++ b/src/reflect/scala/reflect/macros/Context.scala
@@ -6,17 +6,13 @@ package macros
 // the full context should include all traits from scala.reflect.macros (and probably reside in scala-compiler.jar)
 
 trait Context extends Aliases
-                 with CapturedVariables
                  with Enclosures
-                 with Infrastructure
                  with Names
                  with Reifiers
                  with FrontEnds
-                 with Settings
+                 with Infrastructure
                  with Typers
                  with Parsers
-                 with Exprs
-                 with TypeTags
                  with Evals
                  with ExprUtils {
 
@@ -24,7 +20,7 @@ trait Context extends Aliases
   val universe: Universe
 
   /** The mirror of the compile-time universe */
-  val mirror: MirrorOf[universe.type]
+  val mirror: universe.Mirror
 
   /** The type of the prefix tree from which the macro is selected */
   type PrefixType
diff --git a/src/reflect/scala/reflect/macros/Enclosures.scala b/src/reflect/scala/reflect/macros/Enclosures.scala
index a07ff85a08..218cf6ebb3 100644
--- a/src/reflect/scala/reflect/macros/Enclosures.scala
+++ b/src/reflect/scala/reflect/macros/Enclosures.scala
@@ -47,4 +47,8 @@ trait Enclosures {
   /** Compilation unit that contains this macro application.
    */
   val enclosingUnit: CompilationUnit
+
+  /** Compilation run that contains this macro application.
+   */
+  val enclosingRun: Run
 }
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/macros/Exprs.scala b/src/reflect/scala/reflect/macros/Exprs.scala
deleted file mode 100644
index 280d5508c8..0000000000
--- a/src/reflect/scala/reflect/macros/Exprs.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-package scala.reflect
-package macros
-
-trait Exprs {
-  self: Context =>
-
-  def Expr[T: WeakTypeTag](tree: Tree): Expr[T]
-}
diff --git a/src/reflect/scala/reflect/macros/FrontEnds.scala b/src/reflect/scala/reflect/macros/FrontEnds.scala
index d15db0725f..e6b67cfc87 100644
--- a/src/reflect/scala/reflect/macros/FrontEnds.scala
+++ b/src/reflect/scala/reflect/macros/FrontEnds.scala
@@ -1,18 +1,9 @@
 package scala.reflect
 package macros
 
-trait FrontEnds extends scala.reflect.api.FrontEnds {
+trait FrontEnds {
   self: Context =>
 
-  import mirror._
-
-  type Position = universe.Position
-
-  /** Exposes means to control the compiler UI */
-  def frontEnd: FrontEnd
-  def setFrontEnd(frontEnd: FrontEnd): this.type
-  def withFrontEnd[T](frontEnd: FrontEnd)(op: => T): T
-
   /** For sending a message which should not be labeled as a warning/error,
    *  but also shouldn't require -verbose to be visible.
    *  Use ``enclosingPosition'' if you're in doubt what position to pass to ``pos''.
@@ -36,7 +27,4 @@ trait FrontEnds extends scala.reflect.api.FrontEnds {
    *  Use ``enclosingPosition'' if you're in doubt what position to pass to ``pos''.
    */
   def abort(pos: Position, msg: String): Nothing
-
-  /** Drops into interactive mode if supported by the compiler UI */
-  def interactive(): Unit
 }
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/macros/Infrastructure.scala b/src/reflect/scala/reflect/macros/Infrastructure.scala
index 80153ff257..a1ef1c87a3 100644
--- a/src/reflect/scala/reflect/macros/Infrastructure.scala
+++ b/src/reflect/scala/reflect/macros/Infrastructure.scala
@@ -4,77 +4,16 @@ package macros
 trait Infrastructure {
   self: Context =>
 
-  /** Determines whether the compiler expanding a macro targets JVM.
+  /** Exposes macro-specific settings as a list of strings.
+   *  These settings are passed to the compiler via the "-Xmacro-settings:setting1,setting2...,settingN" command-line option.
    */
-  val forJVM: Boolean
+  def settings: List[String]
 
-  /** Determines whether the compiler expanding a macro targets CLR.
+  /** Exposes current compiler settings as a list of options.
+   *  Use `scalac -help`, `scalac -X` and `scalac -Y` to learn about currently supported options.
    */
-  val forMSIL: Boolean
+  def compilerSettings: List[String]
 
-  /** Determines whether the compiler expanding a macro is a presentation compiler.
-   */
-  val forInteractive: Boolean
-
-  /** Determines whether the compiler expanding a macro is a Scaladoc compiler.
-   */
-  val forScaladoc: Boolean
-
-  /** Exposes current compilation run.
-   */
-  val currentRun: Run
-
-  /** Exposes library classpath.
-   */
-  val libraryClassPath: List[java.net.URL]
-
-  /** Exposes a classloader that corresponds to the library classpath.
-   *
-   *  With this classloader you can perform on-the-fly evaluation of macro arguments.
-   *  For example, consider this code snippet:
-   *
-   *    def staticEval[T](x: T) = macro staticEval[T]
-   *
-   *    def staticEval[T](c: Context)(x: c.Expr[T]) = {
-   *      import scala.reflect.runtime.{universe => ru}
-   *      val mirror = ru.runtimeMirror(c.libraryClassLoader)
-   *      import scala.tools.reflect.ToolBox
-   *      val toolBox = mirror.mkToolBox()
-   *      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.eval(imported).asInstanceOf[T]
-   *      ...
-   *    }
-   */
-  def libraryClassLoader: ClassLoader
-
-  /** As seen by macro API, compilation run is an opaque type that can be deconstructed into:
-   *    1) Current compilation unit
-   *    2) List of all compilation units that comprise the run
-   */
-  type Run
-
-  val Run: RunExtractor
-
-  abstract class RunExtractor {
-    def unapply(run: Run): Option[(CompilationUnit, List[CompilationUnit])]
-  }
-
-  /** As seen by macro API, compilation unit is an opaque type that can be deconstructed into:
-   *    1) File that corresponds to the unit (if not applicable, null)
-   *    2) Content of the file (if not applicable, empty array)
-   *    3) Body, i.e. the AST that represents the compilation unit
-   */
-  type CompilationUnit
-
-  val CompilationUnit: CompilationUnitExtractor
-
-  abstract class CompilationUnitExtractor {
-    def unapply(compilationUnit: CompilationUnit): Option[(java.io.File, Array[Char], Tree)]
-  }
-
-  /** Returns a macro definition which triggered this macro expansion.
-   */
-  val currentMacro: Symbol
-}
+  /** Exposes current classpath. */
+  def classPath: List[java.net.URL]
+}
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/macros/Parsers.scala b/src/reflect/scala/reflect/macros/Parsers.scala
index 1742d07b60..c2d4d8a3ab 100644
--- a/src/reflect/scala/reflect/macros/Parsers.scala
+++ b/src/reflect/scala/reflect/macros/Parsers.scala
@@ -5,14 +5,10 @@ trait Parsers {
   self: Context =>
 
   /** .. */
-  // todo. distinguish between `parse` and `parse`
+  // todo. distinguish between parsing an expression and parsing arbitrary code
+  // for example, parsing in expression mode will fail on packages
   def parse(code: String): Tree
+}
 
-  /** Represents an error during parsing
-   */
-  type ParseError <: Throwable
-  val ParseError: ParseErrorExtractor
-  abstract class ParseErrorExtractor {
-    def unapply(error: ParseError): Option[(Position, String)]
-  }
-}
\ No newline at end of file
+// should be path-dependent, otherwise exception handling becomes a mess
+case class ParseError(val pos: scala.reflect.api.Position, val msg: String) extends Throwable(msg)
diff --git a/src/reflect/scala/reflect/macros/Reifiers.scala b/src/reflect/scala/reflect/macros/Reifiers.scala
index c2a6c5be05..ed31663c68 100644
--- a/src/reflect/scala/reflect/macros/Reifiers.scala
+++ b/src/reflect/scala/reflect/macros/Reifiers.scala
@@ -1,21 +1,14 @@
 package scala.reflect
 package macros
 
-import scala.reflect.api.PositionApi
-
 trait Reifiers {
   self: Context =>
 
-  /** Reification prefix that refers to the runtime reflexive universe, ``scala.reflect.runtime.universe''.
-   *  Providing it for the ``prefix'' parameter of ``reifyTree'' or ``reifyType'' will create a full-fledged tree that can be inspected at runtime.
-   */
-  val runtimeUniverse: Tree
-
   /** Given a tree, generate a tree that when compiled and executed produces the original tree.
    *  For more information and examples see the documentation for ``Universe.reify''.
    *
    *  The produced tree will be bound to the specified ``universe'' and ``mirror''.
-   *  Possible values for ``universe'' include ``runtimeUniverse''.
+   *  Possible values for ``universe'' include ``universe.treeBuild.mkRuntimeUniverseRef''.
    *  Possible values for ``mirror'' include ``EmptyTree'' (in that case the reifier will automatically pick an appropriate mirror).
    *
    *  This function is deeply connected to ``Universe.reify'', a macro that reifies arbitrary expressions into runtime trees.
@@ -83,6 +76,6 @@ trait Reifiers {
 
 // made these guys non path-dependent, otherwise exception handling quickly becomes a mess
 
-case class ReificationError(val pos: PositionApi, val msg: String) extends Throwable(msg)
+case class ReificationError(val pos: scala.reflect.api.Position, val msg: String) extends Throwable(msg)
 
-case class UnexpectedReificationError(val pos: PositionApi, val msg: String, val cause: Throwable = null) extends Throwable(msg, cause)
+case class UnexpectedReificationError(val pos: scala.reflect.api.Position, val msg: String, val cause: Throwable = null) extends Throwable(msg, cause)
diff --git a/src/reflect/scala/reflect/macros/Settings.scala b/src/reflect/scala/reflect/macros/Settings.scala
deleted file mode 100644
index a2cdb4c8e1..0000000000
--- a/src/reflect/scala/reflect/macros/Settings.scala
+++ /dev/null
@@ -1,36 +0,0 @@
-package scala.reflect
-package macros
-
-trait Settings {
-  self: Context =>
-
-  /** Exposes macro-specific settings as a list of strings.
-   *  These settings are passed to the compiler via the "-Xmacro-settings:setting1,setting2...,settingN" command-line option.
-   */
-  def settings: List[String]
-
-  /** Exposes current compiler settings as a list of options.
-   *  Use `scalac -help`, `scalac -X` and `scalac -Y` to learn about currently supported options.
-   */
-  def compilerSettings: List[String]
-
-  /** Updates current compiler settings with an option string.
-   *  Use `scalac -help`, `scalac -X` and `scalac -Y` to learn about currently supported options.
-   */
-  def setCompilerSettings(options: String): this.type
-
-  /** Updates current compiler settings with a list of options.
-   *  Use `scalac -help`, `scalac -X` and `scalac -Y` to learn about currently supported options.
-   */
-  def setCompilerSettings(options: List[String]): this.type
-
-  /** Temporarily sets compiler settings to a given option string and executes a given closure.
-   *  Use `scalac -help`, `scalac -X` and `scalac -Y` to learn about currently supported options.
-   */
-  def withCompilerSettings[T](options: String)(op: => T): T
-
-  /** Temporarily sets compiler settings to a given list of options and executes a given closure.
-   *  Use `scalac -help`, `scalac -X` and `scalac -Y` to learn about currently supported options.
-   */
-  def withCompilerSettings[T](options: List[String])(op: => T): T
-}
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/macros/TreeBuilder.scala b/src/reflect/scala/reflect/macros/TreeBuilder.scala
index ca29194859..5f18ab9ee8 100644
--- a/src/reflect/scala/reflect/macros/TreeBuilder.scala
+++ b/src/reflect/scala/reflect/macros/TreeBuilder.scala
@@ -53,4 +53,7 @@ abstract class TreeBuilder {
   def mkMethodCall(receiver: Tree, method: Symbol, targs: List[Type], args: List[Tree]): Tree
   def mkMethodCall(target: Tree, targs: List[Type], args: List[Tree]): Tree
   def mkNullaryCall(method: Symbol, targs: List[Type]): Tree
+
+  /** A tree that refers to the runtime reflexive universe, ``scala.reflect.runtime.universe''. */
+  def mkRuntimeUniverseRef: Tree
 }
diff --git a/src/reflect/scala/reflect/macros/TypeTags.scala b/src/reflect/scala/reflect/macros/TypeTags.scala
deleted file mode 100644
index 2f15e37f6a..0000000000
--- a/src/reflect/scala/reflect/macros/TypeTags.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-package scala.reflect
-package macros
-
-trait TypeTags {
-  self: Context =>
-
-  def WeakTypeTag[T](tpe: Type): WeakTypeTag[T]
-  def TypeTag[T](tpe: Type): TypeTag[T]
-}
diff --git a/src/reflect/scala/reflect/macros/Universe.scala b/src/reflect/scala/reflect/macros/Universe.scala
index f84c11ee63..97d0a8d98a 100644
--- a/src/reflect/scala/reflect/macros/Universe.scala
+++ b/src/reflect/scala/reflect/macros/Universe.scala
@@ -109,4 +109,52 @@ abstract class Universe extends scala.reflect.api.Universe {
   trait IdentContextApi extends IdentApi { this: Ident =>
     def isBackquoted: Boolean
   }
+
+  /** Mark a variable as captured; i.e. force boxing in a *Ref type.
+   */
+  def captureVariable(vble: Symbol): Unit
+
+  /** Mark given identifier as a reference to a captured variable itself
+   *  suppressing dereferencing with the `elem` field.
+   */
+  def referenceCapturedVariable(vble: Symbol): Tree
+
+  /** Convert type of a captured variable to *Ref type.
+   */
+  def capturedVariableType(vble: Symbol): Type
+
+  type Run <: RunContextApi
+
+  /** Compilation run uniquely identifies current invocation of the compiler
+   *  (e.g. can be used to implement per-run caches for macros) and provides access to units of work
+   *  of the invocation (currently processed unit of work and the list of all units).
+   */
+  trait RunContextApi {
+    /** Currently processed unit of work (a real or a virtual file). */
+    def currentUnit: CompilationUnit
+
+    /** All units of work comprising this compilation run. */
+    def units: Iterator[CompilationUnit]
+  }
+
+  type CompilationUnit <: CompilationUnitContextApi
+
+  /** Compilation unit describes a unit of work of the compilation run.
+   *  It provides such information as file name, textual representation of the unit and the underlying AST.
+   */
+  trait CompilationUnitContextApi {
+    /** Source file corresponding to this compilation unit.
+     *
+     *  Exposes information about the file as a part of a real or virtual file system
+     *  along with the contents of that file.
+     *
+     *  The return type is [[scala.reflect.io.AbstractFile]], which belongs to an experimental part of Scala reflection.
+     *  It should not be used unless you know what you are doing. In subsequent releases, this API will be refined
+     *  and exposed as a part of scala.reflect.api.
+     */
+    def source: scala.reflect.internal.util.SourceFile
+
+    /** The AST that corresponds to this compilation unit. */
+    def body: Tree
+  }
 }
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/macros/package.scala b/src/reflect/scala/reflect/macros/package.scala
deleted file mode 100644
index df93785d40..0000000000
--- a/src/reflect/scala/reflect/macros/package.scala
+++ /dev/null
@@ -1,6 +0,0 @@
-package scala.reflect
-
-package object macros {
-
-  type MirrorOf[U <: scala.reflect.api.Universe with Singleton] = scala.reflect.api.MirrorOf[U]
-}