establishes scala.reflect.api#internal

Reflection API exhibits a tension inherent to experimental things:
on the one hand we want it to grow into a beautiful and robust API,
but on the other hand we have to deal with immaturity of underlying mechanisms
by providing not very pretty solutions to enable important use cases.

In Scala 2.10, which was our first stab at reflection API, we didn't
have a systematic approach to dealing with this tension, sometimes exposing
too much of internals (e.g. Symbol.deSkolemize) and sometimes exposing
too little (e.g. there's still no facility to change owners, to do typing
transformations, etc). This resulted in certain confusion with some internal
APIs living among public ones, scaring the newcomers, and some internal APIs
only available via casting, which requires intimate knowledge of the
compiler and breaks compatibility guarantees.

This led to creation of the `internal` API module for the reflection API,
which provides advanced APIs necessary for macros that push boundaries
of the state of the art, clearly demarcating them from the more or less
straightforward rest and providing compatibility guarantees on par with
the rest of the reflection API.

This commit does break source compatibility with reflection API in 2.10,
but the next commit is going to introduce a strategy of dealing with that.

40 files changed, 1328 insertions, 1197 deletions

diff --git a/src/compiler/scala/reflect/macros/contexts/Evals.scala b/src/compiler/scala/reflect/macros/contexts/Evals.scala
index 180a998c39..a715af986c 100644
--- a/src/compiler/scala/reflect/macros/contexts/Evals.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Evals.scala
@@ -9,7 +9,7 @@ trait Evals {
 
   private lazy val evalMirror = ru.runtimeMirror(universe.analyzer.defaultMacroClassloader)
   private lazy val evalToolBox = evalMirror.mkToolBox()
-  private lazy val evalImporter = ru.mkImporter(universe).asInstanceOf[ru.Importer { val from: universe.type }]
+  private lazy val evalImporter = ru.internal.createImporter(universe).asInstanceOf[ru.Importer { val from: universe.type }]
 
   def eval[T](expr: Expr[T]): T = {
     expr.tree match {
diff --git a/src/compiler/scala/reflect/reify/codegen/GenTypes.scala b/src/compiler/scala/reflect/reify/codegen/GenTypes.scala
index a90a3a338b..a6b69e239f 100644
--- a/src/compiler/scala/reflect/reify/codegen/GenTypes.scala
+++ b/src/compiler/scala/reflect/reify/codegen/GenTypes.scala
@@ -45,21 +45,21 @@ trait GenTypes {
       case tpe @ ThisType(clazz) if clazz.isModuleClass && clazz.isStatic =>
         val module = reify(clazz.sourceModule)
         val moduleClass = Select(Select(module, nme.asModule), nme.moduleClass)
-        mirrorFactoryCall(nme.ThisType, moduleClass)
-      case tpe @ ThisType(_) =>
-        reifyProduct(tpe)
+        mirrorBuildCall(nme.ThisType, moduleClass)
+      case tpe @ ThisType(sym) =>
+        reifyBuildCall(nme.ThisType, sym)
       case tpe @ SuperType(thistpe, supertpe) =>
-        reifyProduct(tpe)
+        reifyBuildCall(nme.SuperType, thistpe, supertpe)
       case tpe @ SingleType(pre, sym) =>
-        reifyProduct(tpe)
+        reifyBuildCall(nme.SingleType, pre, sym)
       case tpe @ ConstantType(value) =>
-        mirrorFactoryCall(nme.ConstantType, reifyProduct(value))
+        mirrorBuildCall(nme.ConstantType, reifyProduct(value))
       case tpe @ TypeRef(pre, sym, args) =>
-        reifyProduct(tpe)
+        reifyBuildCall(nme.TypeRef, pre, sym, args)
       case tpe @ TypeBounds(lo, hi) =>
-        reifyProduct(tpe)
+        reifyBuildCall(nme.TypeBounds, lo, hi)
       case tpe @ NullaryMethodType(restpe) =>
-        reifyProduct(tpe)
+        reifyBuildCall(nme.NullaryMethodType, restpe)
       case tpe @ AnnotatedType(anns, underlying) =>
         reifyAnnotatedType(tpe)
       case _ =>
@@ -119,7 +119,8 @@ trait GenTypes {
             // todo. write a test for this
             if (ReflectRuntimeUniverse == NoSymbol) CannotConvertManifestToTagWithoutScalaReflect(tpe, manifestInScope)
             val cm = typer.typed(Ident(ReflectRuntimeCurrentMirror))
-            val tagTree = gen.mkMethodCall(ReflectRuntimeUniverse, nme.manifestToTypeTag, List(tpe), List(cm, manifestInScope))
+            val internal = gen.mkAttributedSelect(gen.mkAttributedRef(ReflectRuntimeUniverse), UniverseInternal)
+            val tagTree = gen.mkMethodCall(Select(internal, nme.manifestToTypeTag), List(tpe), List(cm, manifestInScope))
             Select(Apply(Select(tagTree, nme.in), List(Ident(nme.MIRROR_SHORT))), nme.tpe)
           case _ =>
             EmptyTree
@@ -157,13 +158,13 @@ trait GenTypes {
    */
   private def reifySemiConcreteTypeMember(tpe: Type): Tree = tpe match {
     case tpe @ TypeRef(pre @ SingleType(prepre, presym), sym, args) if sym.isAbstractType && !sym.isExistential =>
-      mirrorFactoryCall(nme.TypeRef, reify(pre), mirrorBuildCall(nme.selectType, reify(sym.owner), reify(sym.name.toString)), reify(args))
+      mirrorBuildCall(nme.TypeRef, reify(pre), mirrorBuildCall(nme.selectType, reify(sym.owner), reify(sym.name.toString)), reify(args))
   }
 
   /** Reify an annotated type, i.e. the one that makes us deal with AnnotationInfos */
   private def reifyAnnotatedType(tpe: AnnotatedType): Tree = {
     val AnnotatedType(anns, underlying) = tpe
-    mirrorFactoryCall(nme.AnnotatedType, mkList(anns map reifyAnnotationInfo), reify(underlying))
+    mirrorBuildCall(nme.AnnotatedType, mkList(anns map reifyAnnotationInfo), reify(underlying))
   }
 
   /** Reify a tough type, i.e. the one that leads to creation of auxiliary symbols */
@@ -172,25 +173,25 @@ trait GenTypes {
 
     def reifyScope(scope: Scope): Tree = {
       scope foreach reifySymDef
-      mirrorCall(nme.newScopeWith, scope.toList map reify: _*)
+      mirrorBuildCall(nme.newScopeWith, scope.toList map reify: _*)
     }
 
     tpe match {
       case tpe @ RefinedType(parents, decls) =>
         reifySymDef(tpe.typeSymbol)
-        mirrorFactoryCall(tpe, reify(parents), reifyScope(decls), reify(tpe.typeSymbol))
+        mirrorBuildCall(nme.RefinedType, reify(parents), reifyScope(decls), reify(tpe.typeSymbol))
       case tpe @ ExistentialType(tparams, underlying) =>
         tparams foreach reifySymDef
-        mirrorFactoryCall(tpe, reify(tparams), reify(underlying))
+        reifyBuildCall(nme.ExistentialType, tparams, underlying)
       case tpe @ ClassInfoType(parents, decls, clazz) =>
         reifySymDef(clazz)
-        mirrorFactoryCall(tpe, reify(parents), reifyScope(decls), reify(tpe.typeSymbol))
+        mirrorBuildCall(nme.ClassInfoType, reify(parents), reifyScope(decls), reify(tpe.typeSymbol))
       case tpe @ MethodType(params, restpe) =>
         params foreach reifySymDef
-        mirrorFactoryCall(tpe, reify(params), reify(restpe))
+        reifyBuildCall(nme.MethodType, params, restpe)
       case tpe @ PolyType(tparams, underlying) =>
         tparams foreach reifySymDef
-        mirrorFactoryCall(tpe, reify(tparams), reify(underlying))
+        reifyBuildCall(nme.PolyType, tparams, underlying)
       case _ =>
         throw new Error("internal error: %s (%s) is not supported".format(tpe, tpe.kind))
     }
diff --git a/src/compiler/scala/reflect/reify/utils/Extractors.scala b/src/compiler/scala/reflect/reify/utils/Extractors.scala
index d052127956..cfc42e31a9 100644
--- a/src/compiler/scala/reflect/reify/utils/Extractors.scala
+++ b/src/compiler/scala/reflect/reify/utils/Extractors.scala
@@ -183,12 +183,12 @@ trait Extractors {
       tree match {
         case
           ValDef(_, name, _, Apply(
-            Select(Select(uref1 @ Ident(_), build1), freeTermFactory),
+            Select(Select(Select(uref1 @ Ident(_), internal1), rs1), freeTermFactory),
             _ :+
-            ApplyCall(Select(Select(uref2 @ Ident(_), build2), flagsRepr), List(Literal(Constant(flags: Long)))) :+
+            ApplyCall(Select(Select(Select(uref2 @ Ident(_), internal2), rs2), flagsRepr), List(Literal(Constant(flags: Long)))) :+
             Literal(Constant(origin: String))))
-        if uref1.name == nme.UNIVERSE_SHORT && build1 == nme.build && acceptFreeTermFactory(freeTermFactory) &&
-           uref2.name == nme.UNIVERSE_SHORT && build2 == nme.build && flagsRepr == nme.FlagsRepr =>
+        if uref1.name == nme.UNIVERSE_SHORT && internal1 == nme.internal && rs1 == nme.reificationSupport && acceptFreeTermFactory(freeTermFactory) &&
+           uref2.name == nme.UNIVERSE_SHORT && internal2 == nme.internal && rs2 == nme.reificationSupport && flagsRepr == nme.FlagsRepr =>
           Some((uref1, name, reifyBinding(tree), flags, origin))
         case _ =>
           None
@@ -201,8 +201,8 @@ trait Extractors {
 
   object FreeRef {
     def unapply(tree: Tree): Option[(Tree, TermName)] = tree match {
-      case Apply(Select(Select(uref @ Ident(_), build), ident), List(Ident(name: TermName)))
-      if build == nme.build && ident == nme.Ident && name.startsWith(nme.REIFY_FREE_PREFIX) =>
+      case Apply(Select(Select(Select(uref @ Ident(_), internal), rs), ident), List(Ident(name: TermName)))
+      if internal == nme.internal && rs == nme.reificationSupport && ident == nme.Ident && name.startsWith(nme.REIFY_FREE_PREFIX) =>
         Some((uref, name))
       case _ =>
         None
@@ -213,15 +213,15 @@ trait Extractors {
     def unapply(tree: Tree): Option[(Tree, TermName, Long, Boolean)] = tree match {
       case
         ValDef(_, name, _, Apply(
-          Select(Select(uref1 @ Ident(_), build1), newNestedSymbol),
+          Select(Select(Select(uref1 @ Ident(_), internal1), rs1), newNestedSymbol),
           List(
             _,
             _,
             _,
-            ApplyCall(Select(Select(uref2 @ Ident(_), build2), flagsRepr), List(Literal(Constant(flags: Long)))),
+            ApplyCall(Select(Select(Select(uref2 @ Ident(_), internal2), rs2), flagsRepr), List(Literal(Constant(flags: Long)))),
             Literal(Constant(isClass: Boolean)))))
-      if uref1.name == nme.UNIVERSE_SHORT && build1 == nme.build && newNestedSymbol == nme.newNestedSymbol &&
-         uref2.name == nme.UNIVERSE_SHORT && build2 == nme.build && flagsRepr == nme.FlagsRepr =>
+      if uref1.name == nme.UNIVERSE_SHORT && internal1 == nme.internal && rs1 == nme.reificationSupport && newNestedSymbol == nme.newNestedSymbol &&
+         uref2.name == nme.UNIVERSE_SHORT && internal2 == nme.internal && rs2 == nme.reificationSupport && flagsRepr == nme.FlagsRepr =>
         Some((uref1, name, flags, isClass))
       case _ =>
         None
diff --git a/src/compiler/scala/reflect/reify/utils/NodePrinters.scala b/src/compiler/scala/reflect/reify/utils/NodePrinters.scala
index e37b861461..3b91d28360 100644
--- a/src/compiler/scala/reflect/reify/utils/NodePrinters.scala
+++ b/src/compiler/scala/reflect/reify/utils/NodePrinters.scala
@@ -32,7 +32,7 @@ trait NodePrinters {
         s = "List\\[List\\[.*?\\].*?\\]".r.replaceAllIn(s, "List")
         s = "List\\[.*?\\]".r.replaceAllIn(s, "List")
         s = s.replace("immutable.this.Nil", "List()")
-        s = """build\.FlagsRepr\((\d+)[lL]\)""".r.replaceAllIn(s, m => {
+        s = """internal\.reificationSupport\.FlagsRepr\((\d+)[lL]\)""".r.replaceAllIn(s, m => {
           flagsAreUsed = true
           show(m.group(1).toLong)
         })
@@ -76,7 +76,6 @@ trait NodePrinters {
       if (mirrorIsUsed) printout += mirror.replace("Mirror[", "scala.reflect.api.Mirror[").trim
       val imports = scala.collection.mutable.ListBuffer[String]()
       imports += nme.UNIVERSE_SHORT.toString
-      // if (buildIsUsed) imports += nme.build
       if (mirrorIsUsed) imports += nme.MIRROR_SHORT.toString
       if (flagsAreUsed) imports += nme.Flag.toString
       printout += s"""import ${imports map (_ + "._") mkString ", "}"""
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 5ce0238b3b..03b76ed99e 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -34,6 +34,7 @@ import backend.jvm.GenASM
 import backend.opt.{ Inliners, InlineExceptionHandlers, ConstantOptimization, ClosureElimination, DeadCodeElimination }
 import backend.icode.analysis._
 import scala.language.postfixOps
+import scala.tools.nsc.ast.{TreeGen => AstTreeGen}
 
 class Global(var currentSettings: Settings, var reporter: Reporter)
     extends SymbolTable
@@ -105,13 +106,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
   // sub-components --------------------------------------------------
 
-  /** Generate ASTs */
-  type TreeGen = scala.tools.nsc.ast.TreeGen
-
   /** Tree generation, usually based on existing symbols. */
   override object gen extends {
     val global: Global.this.type = Global.this
-  } with TreeGen {
+  } with AstTreeGen {
     def mkAttributedCast(tree: Tree, pt: Type): Tree =
       typer.typed(mkCast(tree, pt))
   }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index d3b5564f60..2bb874a8aa 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -1271,7 +1271,8 @@ trait Implicits {
             return SearchFailure
           }
           val cm = typed(Ident(ReflectRuntimeCurrentMirror))
-          val interop = gen.mkMethodCall(ReflectRuntimeUniverse, nme.typeTagToManifest, List(tp), List(cm, tagInScope))
+          val internal = gen.mkAttributedSelect(gen.mkAttributedRef(ReflectRuntimeUniverse), UniverseInternal)
+          val interop = gen.mkMethodCall(Select(internal, nme.typeTagToManifest), List(tp), List(cm, tagInScope))
           wrapResult(interop)
         }
       } else {
diff --git a/src/compiler/scala/tools/reflect/StdTags.scala b/src/compiler/scala/tools/reflect/StdTags.scala
index 5c53c81e8b..ee352c5e02 100644
--- a/src/compiler/scala/tools/reflect/StdTags.scala
+++ b/src/compiler/scala/tools/reflect/StdTags.scala
@@ -18,8 +18,7 @@ trait StdTags {
       new TypeCreator {
         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))
+          u.appliedType(u.definitions.ListClass.toType, List(u.definitions.StringClass.toType))
         }
       })
 
diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
index b43b4653eb..ce6382bec8 100644
--- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
+++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
@@ -217,7 +217,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
           val (expr, freeTerms) = extractFreeTerms(expr0, wrapFreeTermRefs = true)
 
           val (obj, _) = rootMirror.EmptyPackageClass.newModuleAndClassSymbol(
-            nextWrapperModuleName())
+            nextWrapperModuleName(), NoPosition, NoFlags)
 
           val minfo = ClassInfoType(List(ObjectTpe), newScope, obj.moduleClass)
           obj.moduleClass setInfo minfo
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Holes.scala b/src/compiler/scala/tools/reflect/quasiquotes/Holes.scala
index 2027d43264..c2f1bf430d 100644
--- a/src/compiler/scala/tools/reflect/quasiquotes/Holes.scala
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Holes.scala
@@ -120,8 +120,8 @@ trait Holes { self: Quasiquotes =>
     }
 
     private def toStats(tree: Tree): Tree =
-      // q"$u.build.toStats($tree)"
-      Apply(Select(Select(u, nme.build), nme.toStats), tree :: Nil)
+      // q"$u.internal.reificationSupport.toStats($tree)"
+      Apply(Select(Select(Select(u, nme.internal), nme.reificationSupport), nme.toStats), tree :: Nil)
 
     private def toList(tree: Tree, tpe: Type): Tree =
       if (isListType(tpe)) tree
@@ -234,10 +234,10 @@ trait Holes { self: Quasiquotes =>
         }
         val lifter = inferUnliftable(tpe)
         assert(helperName.isTermName)
-        // q"val $name: $u.build.${helperName.toTypeName} = $u.build.$helperName($lifter)"
+        // q"val $name: $u.internal.reificationSupport.${helperName.toTypeName} = $u.internal.reificationSupport.$helperName($lifter)"
         ValDef(NoMods, name,
-          AppliedTypeTree(Select(Select(u, nme.build), helperName.toTypeName), List(TypeTree(tpe))),
-          Apply(Select(Select(u, nme.build), helperName), lifter :: Nil))
+          AppliedTypeTree(Select(Select(Select(u, nme.internal), nme.reificationSupport), helperName.toTypeName), List(TypeTree(tpe))),
+          Apply(Select(Select(Select(u, nme.internal), nme.reificationSupport), helperName), lifter :: Nil))
       }
   }
 }
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala b/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala
index 017e966f63..9078228314 100644
--- a/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala
@@ -64,9 +64,9 @@ trait Reifiers { self: Quasiquotes =>
             val FreshName(prefix) = origname
             val nameTypeName = if (origname.isTermName) tpnme.TermName else tpnme.TypeName
             val freshName = if (origname.isTermName) nme.freshTermName else nme.freshTypeName
-            // q"val ${names.head}: $u.$nameTypeName = $u.build.$freshName($prefix)"
+            // q"val ${names.head}: $u.$nameTypeName = $u.internal.reificationSupport.$freshName($prefix)"
             ValDef(NoMods, names.head, Select(u, nameTypeName),
-              Apply(Select(Select(u, nme.build), freshName), Literal(Constant(prefix)) :: Nil))
+              Apply(Select(Select(Select(u, nme.internal), nme.reificationSupport), freshName), Literal(Constant(prefix)) :: Nil))
         }.toList
         // q"..$freshdefs; $tree"
         SyntacticBlock(freshdefs :+ tree)
@@ -358,7 +358,7 @@ trait Reifiers { self: Quasiquotes =>
       Apply(Select(universe, name), args.toList)
 
     override def mirrorBuildCall(name: TermName, args: Tree*): Tree =
-      Apply(Select(Select(universe, nme.build), name), args.toList)
+      Apply(Select(Select(Select(universe, nme.internal), nme.reificationSupport), name), args.toList)
 
     override def scalaFactoryCall(name: String, args: Tree*): Tree =
       call("scala." + name, args: _*)
diff --git a/src/reflect/scala/reflect/api/BuildUtils.scala b/src/reflect/scala/reflect/api/BuildUtils.scala
deleted file mode 100644
index ec20a89a10..0000000000
--- a/src/reflect/scala/reflect/api/BuildUtils.scala
+++ /dev/null
@@ -1,300 +0,0 @@
-package scala
-package reflect
-package api
-
-/**
- * This is an internal implementation class.
- * @groupname TreeBuilders Tree Building
- */
-private[reflect] trait BuildUtils { self: Universe =>
-
-  /** @group TreeBuilders */
-  val build: BuildApi
-
-  // this API abstracts away the functionality necessary for reification
-  // it's too gimmicky and unstructured to be exposed directly in the universe
-  // but we need it in a publicly available place for reification to work
-
-  /** @group TreeBuilders */
-  abstract class BuildApi {
-    /** Selects type symbol with given simple name `name` from the defined members of `owner`.
-     */
-    def selectType(owner: Symbol, name: String): TypeSymbol
-
-    /** Selects term symbol with given name and type from the defined members of prefix type
-     */
-    def selectTerm(owner: Symbol, name: String): TermSymbol
-
-    /** Selects overloaded method symbol with given name and index
-     */
-    def selectOverloadedMethod(owner: Symbol, name: String, index: Int): MethodSymbol
-
-    /** A fresh symbol with given name `name`, position `pos` and flags `flags` that has
-     *  the current symbol as its owner.
-     */
-    def newNestedSymbol(owner: Symbol, name: Name, pos: Position, flags: FlagSet, isClass: Boolean): Symbol
-
-    /** Create a fresh free term symbol.
-     *  @param   name   the name of the free variable
-     *  @param   value  the value of the free variable at runtime
-     *  @param   flags  (optional) flags of the free variable
-     *  @param   origin debug information that tells where this symbol comes from
-     */
-    def newFreeTerm(name: String, value: => Any, flags: FlagSet = NoFlags, origin: String = null): FreeTermSymbol
-
-    /** Create a fresh free type symbol.
-     *  @param   name   the name of the free variable
-     *  @param   flags  (optional) flags of the free variable
-     *  @param   origin debug information that tells where this symbol comes from
-     */
-    def newFreeType(name: String, flags: FlagSet = NoFlags, origin: String = null): FreeTypeSymbol
-
-    /** Set symbol's type signature to given type.
-     *  @return the symbol itself
-     */
-    def setTypeSignature[S <: Symbol](sym: S, tpe: Type): S
-
-    /** Set symbol's annotations to given annotations `annots`.
-     */
-    def setAnnotations[S <: Symbol](sym: S, annots: List[Annotation]): S
-
-    def This(sym: Symbol): Tree
-
-    def Select(qualifier: Tree, sym: Symbol): Select
-
-    def Ident(sym: Symbol): Ident
-
-    def TypeTree(tp: Type): TypeTree
-
-    def thisPrefix(sym: Symbol): Type
-
-    def setType[T <: Tree](tree: T, tpe: Type): T
-
-    def setSymbol[T <: Tree](tree: T, sym: Symbol): T
-
-    def toStats(tree: Tree): List[Tree]
-
-    def mkAnnotation(tree: Tree): Tree
-
-    def mkAnnotation(trees: List[Tree]): List[Tree]
-
-    def mkRefineStat(stat: Tree): Tree
-
-    def mkRefineStat(stats: List[Tree]): List[Tree]
-
-    def mkPackageStat(stat: Tree): Tree
-
-    def mkPackageStat(stats: List[Tree]): List[Tree]
-
-    def mkEarlyDef(defn: Tree): Tree
-
-    def mkEarlyDef(defns: List[Tree]): List[Tree]
-
-    def RefTree(qual: Tree, sym: Symbol): Tree
-
-    def freshTermName(prefix: String): TermName
-
-    def freshTypeName(prefix: String): TypeName
-
-    val ImplicitParams: ImplicitParamsExtractor
-
-    trait ImplicitParamsExtractor {
-      def apply(paramss: List[List[ValDef]], implparams: List[ValDef]): List[List[ValDef]]
-      def unapply(vparamss: List[List[ValDef]]): Some[(List[List[ValDef]], List[ValDef])]
-    }
-
-    val ScalaDot: ScalaDotExtractor
-
-    trait ScalaDotExtractor {
-      def apply(name: Name): Tree
-      def unapply(tree: Tree): Option[Name]
-    }
-
-    val FlagsRepr: FlagsReprExtractor
-
-    trait FlagsReprExtractor {
-      def apply(value: Long): FlagSet
-      def unapply(flags: Long): Some[Long]
-    }
-
-    val SyntacticTypeApplied: SyntacticTypeAppliedExtractor
-
-    trait SyntacticTypeAppliedExtractor {
-      def apply(tree: Tree, targs: List[Tree]): Tree
-      def unapply(tree: Tree): Some[(Tree, List[Tree])]
-    }
-
-    val SyntacticApplied: SyntacticAppliedExtractor
-
-    trait SyntacticAppliedExtractor {
-      def apply(tree: Tree, argss: List[List[Tree]]): Tree
-      def unapply(tree: Tree): Some[(Tree, List[List[Tree]])]
-    }
-
-    val SyntacticClassDef: SyntacticClassDefExtractor
-
-    trait SyntacticClassDefExtractor {
-      def apply(mods: Modifiers, name: TypeName, tparams: List[Tree],
-                constrMods: Modifiers, vparamss: List[List[Tree]],
-                earlyDefs: List[Tree], parents: List[Tree], selfType: Tree, body: List[Tree]): ClassDef
-      def unapply(tree: Tree): Option[(Modifiers, TypeName, List[TypeDef], Modifiers, List[List[ValDef]],
-                                       List[Tree], List[Tree], ValDef, List[Tree])]
-    }
-
-    val SyntacticTraitDef: SyntacticTraitDefExtractor
-
-    trait SyntacticTraitDefExtractor {
-      def apply(mods: Modifiers, name: TypeName, tparams: List[Tree],
-                earlyDefs: List[Tree], parents: List[Tree], selfType: Tree, body: List[Tree]): ClassDef
-      def unapply(tree: Tree): Option[(Modifiers, TypeName, List[TypeDef],
-                                       List[Tree], List[Tree], ValDef, List[Tree])]
-    }
-
-    val SyntacticObjectDef: SyntacticObjectDefExtractor
-
-    trait SyntacticObjectDefExtractor {
-      def apply(mods: Modifiers, name: TermName, earlyDefs: List[Tree],
-                parents: List[Tree], selfType: Tree, body: List[Tree]): ModuleDef
-      def unapply(tree: Tree): Option[(Modifiers, TermName, List[Tree], List[Tree], ValDef, List[Tree])]
-    }
-
-    val SyntacticPackageObjectDef: SyntacticPackageObjectDefExtractor
-
-    trait SyntacticPackageObjectDefExtractor {
-      def apply(name: TermName, earlyDefs: List[Tree],
-                parents: List[Tree], selfType: Tree, body: List[Tree]): PackageDef
-      def unapply(tree: Tree): Option[(TermName, List[Tree], List[Tree], ValDef, List[Tree])]
-    }
-
-    val SyntacticTuple: SyntacticTupleExtractor
-    val SyntacticTupleType: SyntacticTupleExtractor
-
-    trait SyntacticTupleExtractor {
-      def apply(args: List[Tree]): Tree
-      def unapply(tree: Tree): Option[List[Tree]]
-    }
-
-    val SyntacticBlock: SyntacticBlockExtractor
-
-    trait SyntacticBlockExtractor {
-      def apply(stats: List[Tree]): Tree
-      def unapply(tree: Tree): Option[List[Tree]]
-    }
-
-    val SyntacticNew: SyntacticNewExtractor
-
-    trait SyntacticNewExtractor {
-      def apply(earlyDefs: List[Tree], parents: List[Tree], selfType: Tree, body: List[Tree]): Tree
-      def unapply(tree: Tree): Option[(List[Tree], List[Tree], ValDef, List[Tree])]
-    }
-
-    val SyntacticFunctionType: SyntacticFunctionTypeExtractor
-
-    trait SyntacticFunctionTypeExtractor {
-      def apply(argtpes: List[Tree], restpe: Tree): Tree
-      def unapply(tree: Tree): Option[(List[Tree], Tree)]
-    }
-
-    val SyntacticFunction: SyntacticFunctionExtractor
-
-    trait SyntacticFunctionExtractor {
-      def apply(params: List[Tree], body: Tree): Function
-
-      def unapply(tree: Function): Option[(List[ValDef], Tree)]
-    }
-
-    val SyntacticDefDef: SyntacticDefDefExtractor
-
-    trait SyntacticDefDefExtractor {
-      def apply(mods: Modifiers, name: TermName, tparams: List[Tree],
-                vparamss: List[List[Tree]], tpt: Tree, rhs: Tree): DefDef
-
-      def unapply(tree: Tree): Option[(Modifiers, TermName, List[TypeDef], List[List[ValDef]], Tree, Tree)]
-    }
-
-    val SyntacticValDef: SyntacticValDefExtractor
-    val SyntacticVarDef: SyntacticValDefExtractor
-
-    trait SyntacticValDefExtractor {
-      def apply(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree): ValDef
-      def unapply(tree: Tree): Option[(Modifiers, TermName, Tree, Tree)]
-    }
-
-    val SyntacticAssign: SyntacticAssignExtractor
-
-    trait SyntacticAssignExtractor {
-      def apply(lhs: Tree, rhs: Tree): Tree
-      def unapply(tree: Tree): Option[(Tree, Tree)]
-    }
-
-    val SyntacticValFrom: SyntacticValFromExtractor
-
-    trait SyntacticValFromExtractor {
-      def apply(pat: Tree, rhs: Tree): Tree
-      def unapply(tree: Tree): Option[(Tree, Tree)]
-    }
-
-    val SyntacticValEq: SyntacticValEqExtractor
-
-    trait SyntacticValEqExtractor {
-      def apply(pat: Tree, rhs: Tree): Tree
-      def unapply(tree: Tree): Option[(Tree, Tree)]
-    }
-
-    val SyntacticFilter: SyntacticFilterExtractor
-
-    trait SyntacticFilterExtractor {
-      def apply(test: Tree): Tree
-      def unapply(tree: Tree): Option[(Tree)]
-    }
-
-    val SyntacticEmptyTypeTree: SyntacticEmptyTypeTreeExtractor
-
-    trait SyntacticEmptyTypeTreeExtractor {
-      def apply(): TypeTree
-      def unapply(tt: TypeTree): Boolean
-    }
-
-    val SyntacticFor: SyntacticForExtractor
-    val SyntacticForYield: SyntacticForExtractor
-
-    trait SyntacticForExtractor {
-      def apply(enums: List[Tree], body: Tree): Tree
-      def unapply(tree: Tree): Option[(List[Tree], Tree)]
-    }
-
-    def UnliftListElementwise[T](unliftable: Unliftable[T]): UnliftListElementwise[T]
-    trait UnliftListElementwise[T] {
-      def unapply(lst: List[Tree]): Option[List[T]]
-    }
-
-    def UnliftListOfListsElementwise[T](unliftable: Unliftable[T]): UnliftListOfListsElementwise[T]
-    trait UnliftListOfListsElementwise[T] {
-      def unapply(lst: List[List[Tree]]): Option[List[List[T]]]
-    }
-
-    val SyntacticMatch: SyntacticMatchExtractor
-    trait SyntacticMatchExtractor {
-      def apply(selector: Tree, cases: List[Tree]): Match
-      def unapply(tree: Match): Option[(Tree, List[CaseDef])]
-    }
-
-    val SyntacticTry: SyntacticTryExtractor
-    trait SyntacticTryExtractor {
-      def apply(block: Tree, catches: List[Tree], finalizer: Tree): Try
-      def unapply(tree: Try): Option[(Tree, List[CaseDef], Tree)]
-    }
-
-    val SyntacticIdent: SyntacticIdentExtractor
-    trait SyntacticIdentExtractor {
-      def apply(name: Name, isBackquoted: Boolean = false): Ident
-      def unapply(tree: Ident): Option[(Name, Boolean)]
-    }
-
-    val SyntacticImport: SyntacticImportExtractor
-    trait SyntacticImportExtractor {
-      def apply(expr: Tree, selectors: List[Tree]): Import
-      def unapply(imp: Import): Some[(Tree, List[Tree])]
-    }
-  }
-}
diff --git a/src/reflect/scala/reflect/api/ImplicitTags.scala b/src/reflect/scala/reflect/api/ImplicitTags.scala
index 4fd7709089..aca0692d0d 100644
--- a/src/reflect/scala/reflect/api/ImplicitTags.scala
+++ b/src/reflect/scala/reflect/api/ImplicitTags.scala
@@ -51,8 +51,6 @@ trait ImplicitTags {
   implicit val TypeSymbolTag: ClassTag[TypeSymbol]
   implicit val ModuleSymbolTag: ClassTag[ModuleSymbol]
   implicit val ClassSymbolTag: ClassTag[ClassSymbol]
-  implicit val FreeTermSymbolTag: ClassTag[FreeTermSymbol]
-  implicit val FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]
 
   // Tags for misc Tree relatives.
   implicit val PositionTag: ClassTag[Position]
@@ -91,7 +89,6 @@ trait ImplicitTags {
   implicit val NewTag: ClassTag[New]
   implicit val PackageDefTag: ClassTag[PackageDef]
   implicit val RefTreeTag: ClassTag[RefTree]
-  implicit val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]
   implicit val ReturnTag: ClassTag[Return]
   implicit val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]
   implicit val SelectTag: ClassTag[Select]
diff --git a/src/reflect/scala/reflect/api/Importers.scala b/src/reflect/scala/reflect/api/Importers.scala
deleted file mode 100644
index 6539137cee..0000000000
--- a/src/reflect/scala/reflect/api/Importers.scala
+++ /dev/null
@@ -1,104 +0,0 @@
-package scala
-package reflect
-package api
-
-/**
- * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
- *
- * This trait provides support for importers, a facility to migrate reflection artifacts between universes.
- * ''Note: this trait should typically be used only rarely.''
- *
- *  Reflection artifacts, such as [[scala.reflect.api.Symbols Symbols]] and [[scala.reflect.api.Types Types]],
- *  are contained in [[scala.reflect.api.Universe Universe]]s. Typically all processing happens
- *  within a single `Universe` (e.g. a compile-time macro `Universe` or a runtime reflection `Universe`), but sometimes
- *  there is a need to migrate artifacts from one `Universe` to another. For example, runtime compilation works by
- *  importing runtime reflection trees into a runtime compiler universe, compiling the importees and exporting the
- *  result back.
- *
- *  Reflection artifacts are firmly grounded in their `Universe`s, which is reflected by the fact that types of artifacts
- *  from different universes are not compatible. By using `Importer`s, however, they be imported from one universe
- *  into another. For example, to import `foo.bar.Baz` from the source `Universe` to the target `Universe`,
- *  an importer will first check whether the entire owner chain exists in the target `Universe`.
- *  If it does, then nothing else will be done. Otherwise, the importer will recreate the entire owner chain
- *  and will import the corresponding type signatures into the target `Universe`.
- *
- *  Since importers match `Symbol` tables of the source and the target `Universe`s using plain string names,
- *  it is programmer's responsibility to make sure that imports don't distort semantics, e.g., that
- *  `foo.bar.Baz` in the source `Universe` means the same that `foo.bar.Baz` does in the target `Universe`.
- *
- *  === Example ===
- *
- *  Here's how one might implement a macro that performs compile-time evaluation of its argument
- *  by using a runtime compiler to compile and evaluate a tree that belongs to a compile-time compiler:
- *
- *  {{{
- *  def staticEval[T](x: T) = macro staticEval[T]
- *
- *  def staticEval[T](c: scala.reflect.macros.blackbox.Context)(x: c.Expr[T]) = {
- *    // creates a runtime reflection universe to host runtime compilation
- *    import scala.reflect.runtime.{universe => ru}
- *    val mirror = ru.runtimeMirror(c.libraryClassLoader)
- *    import scala.tools.reflect.ToolBox
- *    val toolBox = mirror.mkToolBox()
- *
- *    // runtime reflection universe and compile-time macro universe are different
- *    // therefore an importer is needed to bridge them
- *    // currently mkImporter requires a cast to correctly assign the path-dependent types
- *    val importer0 = ru.mkImporter(c.universe)
- *    val importer = importer0.asInstanceOf[ru.Importer { val from: c.universe.type }]
- *
- *    // the created importer is used to turn a compiler tree into a runtime compiler tree
- *    // both compilers use the same classpath, so semantics remains intact
- *    val imported = importer.importTree(tree)
- *
- *    // after the tree is imported, it can be evaluated as usual
- *    val tree = toolBox.untypecheck(imported.duplicate)
- *    val valueOfX = toolBox.eval(imported).asInstanceOf[T]
- *    ...
- *  }
- *  }}}
- *
- * @group ReflectionAPI
- */
-trait Importers { self: Universe =>
-
-  /** Creates an importer that moves reflection artifacts between universes.
-   *  @group Importers
-   */
-  def mkImporter(from0: Universe): Importer { val from: from0.type }
-
-  /** The API of importers.
-   *  The main source of information about importers is the [[scala.reflect.api.Importers]] page.
-   *  @group Importers
-   */
-  trait Importer {
-    /** The source universe of reflection artifacts that will be processed.
-     *  The target universe is universe that created this importer with `mkImporter`.
-     */
-    val from: Universe
-
-    /** An importer that works in reverse direction, namely:
-     *  imports reflection artifacts from the current universe to the universe specified in `from`.
-     */
-    val reverse: from.Importer { val from: self.type }
-
-    /** In the current universe, locates or creates a symbol that corresponds to the provided symbol in the source universe.
-     *  If necessary imports the owner chain, companions, type signature, annotations and attachments.
-     */
-    def importSymbol(sym: from.Symbol): Symbol
-
-    /** In the current universe, locates or creates a type that corresponds to the provided type in the source universe.
-     *  If necessary imports the underlying symbols, annotations, scopes and trees.
-     */
-    def importType(tpe: from.Type): Type
-
-    /** In the current universe, creates a tree that corresponds to the provided tree in the source universe.
-     *  If necessary imports the underlying symbols, types and attachments.
-     */
-    def importTree(tree: from.Tree): Tree
-
-    /** In the current universe, creates a position that corresponds to the provided position in the source universe.
-     */
-    def importPosition(pos: from.Position): Position
-  }
-}
diff --git a/src/reflect/scala/reflect/api/Internals.scala b/src/reflect/scala/reflect/api/Internals.scala
new file mode 100644
index 0000000000..93796ad29e
--- /dev/null
+++ b/src/reflect/scala/reflect/api/Internals.scala
@@ -0,0 +1,859 @@
+package scala
+package reflect
+package api
+
+import scala.language.implicitConversions
+
+/**
+ *  <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
+ *
+ *  This trait assembles APIs occasionally necessary for performing low-level operations on reflection artifacts.
+ *  See [[Internals#InternalApi]] for more information about nature, usefulness and compatibility guarantees of these APIs.
+ *
+ *  @group ReflectionAPI
+ */
+trait Internals { self: Universe =>
+
+  /** @see [[InternalApi]]
+   *  @group Internal
+   */
+  val internal: Internal
+
+  /** @see [[InternalApi]]
+   *  @group Internal
+   */
+  type Internal <: InternalApi
+
+  /** Reflection API exhibits a tension inherent to experimental things:
+   *  on the one hand we want it to grow into a beautiful and robust API,
+   *  but on the other hand we have to deal with immaturity of underlying mechanisms
+   *  by providing not very pretty solutions to enable important use cases.
+   *
+   *  In Scala 2.10, which was our first stab at reflection API, we didn't have a systematic
+   *  approach to dealing with this tension, sometimes exposing too much of internals (e.g. Symbol.deSkolemize)
+   *  and sometimes exposing too little (e.g. there's still no facility to change owners, to do typing
+   *  transformations, etc). This resulted in certain confusion with some internal APIs
+   *  living among public ones, scaring the newcomers, and some internal APIs only available via casting,
+   *  which requires intimate knowledge of the compiler and breaks compatibility guarantees.
+   *
+   *  This led to creation of the `internal` API module for the reflection API, which
+   *  provides advanced APIs necessary for macros that push boundaries of the state of the art,
+   *  clearly demarcating them from the more or less straightforward rest and
+   *  providing compatibility guarantees on par with the rest of the reflection API
+   *  (full compatibility within minor releases, best effort towards backward compatibility within major releases,
+   *  clear replacement path in case of rare incompatible changes in major releases).
+   *
+   *  The `internal` module itself (the value that implements [[InternalApi]]) isn't defined here,
+   *  in [[scala.reflect.api.Universe]], but is provided on per-implementation basis. Runtime API endpoint
+   *  ([[scala.reflect.runtime.universe]]) provides `universe.compat: InternalApi`, whereas compile-time API endpoints
+   *  (instances of [[scala.reflect.macros.Context]]) provide `c.compat: ContextInternalApi`, which extends `InternalApi`
+   *  with additional universe-specific and context-specific functionality.
+   *
+   *  @group Internal
+   */
+  trait InternalApi {
+    /** This is an internal implementation module.
+     */
+    val reificationSupport: ReificationSupportApi
+
+    /** Creates an importer that moves reflection artifacts between universes.
+     *  @see [[Importer]]
+     */
+    // SI-6241: move importers to a mirror
+    def createImporter(from0: Universe): Importer { val from: from0.type }
+
+    /**
+     * Convert a [[scala.reflect.api.TypeTags#TypeTag]] to a [[scala.reflect.Manifest]].
+     *
+     * Compiler usually generates these conversions automatically, when a type tag for a type `T` is in scope,
+     * and an implicit of type `Manifest[T]` is requested, but this method can also be called manually.
+     * For example:
+     * {{{
+     * typeTagToManifest(scala.reflect.runtime.currentMirror, implicitly[TypeTag[String]])
+     * }}}
+     * @group TagInterop
+     */
+    def typeTagToManifest[T: ClassTag](mirror: Any, tag: Universe#TypeTag[T]): Manifest[T] =
+      throw new UnsupportedOperationException("This universe does not support tag -> manifest conversions. Use a JavaUniverse, e.g. the scala.reflect.runtime.universe.")
+
+    /**
+     * Convert a [[scala.reflect.Manifest]] to a [[scala.reflect.api.TypeTags#TypeTag]].
+     *
+     * Compiler usually generates these conversions automatically, when a manifest for a type `T` is in scope,
+     * and an implicit of type `TypeTag[T]` is requested, but this method can also be called manually.
+     * For example:
+     * {{{
+     * manifestToTypeTag(scala.reflect.runtime.currentMirror, implicitly[Manifest[String]])
+     * }}}
+     * @group TagInterop
+     */
+    def manifestToTypeTag[T](mirror: Any, manifest: Manifest[T]): Universe#TypeTag[T] =
+      throw new UnsupportedOperationException("This universe does not support manifest -> tag conversions. Use a JavaUniverse, e.g. the scala.reflect.runtime.universe.")
+
+    /** Create a new scope with the given initial elements.
+     *  @group Scopes
+     */
+    def newScopeWith(elems: Symbol*): Scope
+
+    /** Extracts free term symbols from a tree that is reified or contains reified subtrees.
+     */
+    def freeTerms(tree: Tree): List[FreeTermSymbol]
+
+    /** Extracts free type symbols from a tree that is reified or contains reified subtrees.
+     */
+    def freeTypes(tree: Tree): List[FreeTypeSymbol]
+
+    /** Substitute symbols in `to` for corresponding occurrences of references to
+     *  symbols `from` in this type.
+     */
+    def substituteSymbols(tree: Tree, from: List[Symbol], to: List[Symbol]): Tree
+
+    /** Substitute types in `to` for corresponding occurrences of references to
+     *  symbols `from` in this tree.
+     */
+    def substituteTypes(tree: Tree, from: List[Symbol], to: List[Type]): Tree
+
+    /** Substitute given tree `to` for occurrences of nodes that represent
+     *  `C.this`, where `C` referes to the given class `clazz`.
+     */
+    def substituteThis(tree: Tree, clazz: Symbol, to: Tree): Tree
+
+    /** A factory method for `ClassDef` nodes.
+     */
+    def classDef(sym: Symbol, impl: Template): ClassDef
+
+    /** A factory method for `ModuleDef` nodes.
+     */
+    def moduleDef(sym: Symbol, impl: Template): ModuleDef
+
+    /** A factory method for `ValDef` nodes.
+     */
+    def valDef(sym: Symbol, rhs: Tree): ValDef
+
+    /** A factory method for `ValDef` nodes.
+     */
+    def valDef(sym: Symbol): ValDef
+
+    /** A factory method for `DefDef` nodes.
+     */
+    def defDef(sym: Symbol, mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree): DefDef
+
+    /** A factory method for `DefDef` nodes.
+     */
+    def defDef(sym: Symbol, vparamss: List[List[ValDef]], rhs: Tree): DefDef
+
+    /** A factory method for `DefDef` nodes.
+     */
+    def defDef(sym: Symbol, mods: Modifiers, rhs: Tree): DefDef
+
+    /** A factory method for `DefDef` nodes.
+     */
+    def defDef(sym: Symbol, rhs: Tree): DefDef
+
+    /** A factory method for `DefDef` nodes.
+     */
+    def defDef(sym: Symbol, rhs: List[List[Symbol]] => Tree): DefDef
+
+    /** A factory method for `TypeDef` nodes.
+     */
+    def typeDef(sym: Symbol, rhs: Tree): TypeDef
+
+    /** A factory method for `TypeDef` nodes.
+     */
+    def typeDef(sym: Symbol): TypeDef
+
+    /** A factory method for `LabelDef` nodes.
+     */
+    def labelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef
+
+    /** Does this symbol represent a free term captured by reification?
+     *  If yes, `isTerm` is also guaranteed to be true.
+     */
+    def isFreeTerm(symbol: Symbol): Boolean
+
+    /** This symbol cast to a free term symbol.
+     *  @throws ScalaReflectionException if `isFreeTerm` is false.
+     */
+    def asFreeTerm(symbol: Symbol): FreeTermSymbol
+
+    /** Does this symbol represent a free type captured by reification?
+     *  If yes, `isType` is also guaranteed to be true.
+     */
+    def isFreeType(symbol: Symbol): Boolean
+
+    /** This symbol cast to a free type symbol.
+     *  @throws ScalaReflectionException if `isFreeType` is false.
+     */
+    def asFreeType(symbol: Symbol): FreeTypeSymbol
+
+    def newTermSymbol(owner: Symbol, name: TermName, pos: Position = NoPosition, flags: FlagSet = NoFlags): TermSymbol
+
+    def newModuleAndClassSymbol(owner: Symbol, name: Name, pos: Position = NoPosition, flags: FlagSet = NoFlags): (ModuleSymbol, ClassSymbol)
+
+    def newMethodSymbol(owner: Symbol, name: TermName, pos: Position = NoPosition, flags: FlagSet = NoFlags): MethodSymbol
+
+    def newTypeSymbol(owner: Symbol, name: TypeName, pos: Position = NoPosition, flags: FlagSet = NoFlags): TypeSymbol
+
+    def newClassSymbol(owner: Symbol, name: TypeName, pos: Position = NoPosition, flags: FlagSet = NoFlags): ClassSymbol
+
+    def newFreeTerm(name: String, value: => Any, flags: FlagSet = NoFlags, origin: String = null): FreeTermSymbol
+
+    def newFreeType(name: String, flags: FlagSet = NoFlags, origin: String = null): FreeTypeSymbol
+
+    /** Does this symbol or its underlying type represent a typechecking error?
+     */
+    def isErroneous(symbol: Symbol): Boolean
+
+    /** Does this symbol represent the definition of a skolem?
+     *  Skolems are used during typechecking to represent type parameters viewed from inside their scopes.
+     */
+    def isSkolem(symbol: Symbol): Boolean
+
+    /** If this symbol is a skolem, its corresponding type parameter, otherwise the symbol itself.
+     *
+     *  [[https://groups.google.com/forum/#!msg/scala-internals/0j8laVNTQsI/kRXMF_c8bGsJ To quote Martin Odersky]],
+     *  skolems are synthetic type "constants" that are copies of existentially bound or universally
+     *  bound type variables. E.g. if one is inside the right-hand side of a method:
+     *
+     *  {{{
+     *  def foo[T](x: T) = ... foo[List[T]]....
+     *  }}}
+     *
+     *  the skolem named `T` refers to the unknown type instance of `T` when `foo` is called. It needs to be different
+     *  from the type parameter because in a recursive call as in the `foo[List[T]]` above the type parameter gets
+     *  substituted with `List[T]`, but the ''type skolem'' stays what it is.
+     *
+     *  The other form of skolem is an ''existential skolem''. Say one has a function
+     *
+     *  {{{
+     *  def bar(xs: List[T] forSome { type T }) = xs.head
+     *  }}}
+     *
+     *  then each occurrence of `xs` on the right will have type `List[T']` where `T'` is a fresh copy of `T`.
+     */
+    def deSkolemize(symbol: Symbol): Symbol
+
+    /** A creator for `ThisType` types.
+     */
+    def thisType(sym: Symbol): Type
+
+    /** A creator for `SingleType` types.
+     */
+    def singleType(pre: Type, sym: Symbol): Type
+
+    /** A creator for `SuperType` types.
+     */
+    def superType(thistpe: Type, supertpe: Type): Type
+
+    /** A creator for `ConstantType` types.
+     */
+    def constantType(value: Constant): ConstantType
+
+    /** A creator for `TypeRef` types.
+     */
+    def typeRef(pre: Type, sym: Symbol, args: List[Type]): Type
+
+    /** A creator for `RefinedType` types.
+     */
+    def refinedType(parents: List[Type], decls: Scope): RefinedType
+
+    /** A creator for `RefinedType` types.
+     */
+    def refinedType(parents: List[Type], owner: Symbol): Type
+
+    /** A creator for `RefinedType` types.
+     */
+    def refinedType(parents: List[Type], owner: Symbol, decls: Scope): Type
+
+    /** A creator for `RefinedType` types.
+     */
+    def refinedType(parents: List[Type], owner: Symbol, decls: Scope, pos: Position): Type
+
+    /** A creator for intersection type where intersections of a single type are
+     *  replaced by the type itself.
+     */
+    def intersectionType(tps: List[Type]): Type
+
+    /** A creator for intersection type where intersections of a single type are
+     *  replaced by the type itself, and repeated parent classes are merged.
+     *
+     *  !!! Repeated parent classes are not merged - is this a bug in the
+     *  comment or in the code?
+     */
+    def intersectionType(tps: List[Type], owner: Symbol): Type
+
+    /** A creator for `ClassInfoType` types.
+     */
+    def classInfoType(parents: List[Type], decls: Scope, typeSymbol: Symbol): ClassInfoType
+
+    /** A creator for `MethodType` types.
+     */
+    def methodType(params: List[Symbol], resultType: Type): MethodType
+
+    /** A creator for `NullaryMethodType` types.
+     */
+    def nullaryMethodType(resultType: Type): NullaryMethodType
+
+    /** A creator for type parameterizations that strips empty type parameter lists.
+     *  Use this factory method to indicate the type has kind * (it's a polymorphic value)
+     *  until we start tracking explicit kinds equivalent to typeFun (except that the latter requires tparams nonEmpty).
+     */
+    def polyType(tparams: List[Symbol], tpe: Type): PolyType
+
+    /** A creator for `ExistentialType` types.
+     */
+    def existentialType(quantified: List[Symbol], underlying: Type): ExistentialType
+
+    /** A creator for existential types. This generates:
+     *
+     *  {{{
+     *    tpe1 where { tparams }
+     *  }}}
+     *
+     *  where `tpe1` is the result of extrapolating `tpe` with regard to `tparams`.
+     *  Extrapolating means that type variables in `tparams` occurring
+     *  in covariant positions are replaced by upper bounds, (minus any
+     *  SingletonClass markers), type variables in `tparams` occurring in
+     *  contravariant positions are replaced by upper bounds, provided the
+     *  resulting type is legal with regard to stability, and does not contain
+     *  any type variable in `tparams`.
+     *
+     *  The abstraction drops all type parameters that are not directly or
+     *  indirectly referenced by type `tpe1`. If there are no remaining type
+     *  parameters, simply returns result type `tpe`.
+     *  @group TypeCreators
+     */
+    def existentialAbstraction(tparams: List[Symbol], tpe0: Type): Type
+
+    /** A creator for `AnnotatedType` types.
+     */
+    def annotatedType(annotations: List[Annotation], underlying: Type): AnnotatedType
+
+    /** A creator for `TypeBounds` types.
+     */
+    def typeBounds(lo: Type, hi: Type): TypeBounds
+
+    /** A creator for `BoundedWildcardType` types.
+     */
+    def boundedWildcardType(bounds: TypeBounds): BoundedWildcardType
+  }
+
+  /** This is an internal implementation class.
+   *  @group Internal
+   */
+  // this API abstracts away the functionality necessary for reification and quasiquotes
+  // it's too gimmicky and unstructured to be exposed directly in the universe
+  // but we need it in a publicly available place for reification to work
+  trait ReificationSupportApi {
+    /** Selects type symbol with given simple name `name` from the defined members of `owner`.
+     */
+    def selectType(owner: Symbol, name: String): TypeSymbol
+
+    /** Selects term symbol with given name and type from the defined members of prefix type
+     */
+    def selectTerm(owner: Symbol, name: String): TermSymbol
+
+    /** Selects overloaded method symbol with given name and index
+     */
+    def selectOverloadedMethod(owner: Symbol, name: String, index: Int): MethodSymbol
+
+    /** A fresh symbol with given name `name`, position `pos` and flags `flags` that has
+     *  the current symbol as its owner.
+     */
+    def newNestedSymbol(owner: Symbol, name: Name, pos: Position, flags: FlagSet, isClass: Boolean): Symbol
+
+    def newScopeWith(elems: Symbol*): Scope
+
+    /** Create a fresh free term symbol.
+     *  @param   name   the name of the free variable
+     *  @param   value  the value of the free variable at runtime
+     *  @param   flags  (optional) flags of the free variable
+     *  @param   origin debug information that tells where this symbol comes from
+     */
+    def newFreeTerm(name: String, value: => Any, flags: FlagSet = NoFlags, origin: String = null): FreeTermSymbol
+
+    /** Create a fresh free type symbol.
+     *  @param   name   the name of the free variable
+     *  @param   flags  (optional) flags of the free variable
+     *  @param   origin debug information that tells where this symbol comes from
+     */
+    def newFreeType(name: String, flags: FlagSet = NoFlags, origin: String = null): FreeTypeSymbol
+
+    /** Set symbol's type signature to given type.
+     *  @return the symbol itself
+     */
+    def setTypeSignature[S <: Symbol](sym: S, tpe: Type): S
+
+    /** Set symbol's annotations to given annotations `annots`.
+     */
+    def setAnnotations[S <: Symbol](sym: S, annots: List[Annotation]): S
+
+    def This(sym: Symbol): Tree
+
+    def Select(qualifier: Tree, sym: Symbol): Select
+
+    def Ident(sym: Symbol): Ident
+
+    def TypeTree(tp: Type): TypeTree
+
+    def ThisType(sym: Symbol): Type
+
+    def SingleType(pre: Type, sym: Symbol): Type
+
+    def SuperType(thistpe: Type, supertpe: Type): Type
+
+    def ConstantType(value: Constant): ConstantType
+
+    def TypeRef(pre: Type, sym: Symbol, args: List[Type]): Type
+
+    def RefinedType(parents: List[Type], decls: Scope, typeSymbol: Symbol): RefinedType
+
+    def ClassInfoType(parents: List[Type], decls: Scope, typeSymbol: Symbol): ClassInfoType
+
+    def MethodType(params: List[Symbol], resultType: Type): MethodType
+
+    def NullaryMethodType(resultType: Type): NullaryMethodType
+
+    def PolyType(typeParams: List[Symbol], resultType: Type): PolyType
+
+    def ExistentialType(quantified: List[Symbol], underlying: Type): ExistentialType
+
+    def AnnotatedType(annotations: List[Annotation], underlying: Type): AnnotatedType
+
+    def TypeBounds(lo: Type, hi: Type): TypeBounds
+
+    def BoundedWildcardType(bounds: TypeBounds): BoundedWildcardType
+
+    def thisPrefix(sym: Symbol): Type
+
+    def setType[T <: Tree](tree: T, tpe: Type): T
+
+    def setSymbol[T <: Tree](tree: T, sym: Symbol): T
+
+    def toStats(tree: Tree): List[Tree]
+
+    def mkAnnotation(tree: Tree): Tree
+
+    def mkAnnotation(trees: List[Tree]): List[Tree]
+
+    def mkRefineStat(stat: Tree): Tree
+
+    def mkRefineStat(stats: List[Tree]): List[Tree]
+
+    def mkPackageStat(stat: Tree): Tree
+
+    def mkPackageStat(stats: List[Tree]): List[Tree]
+
+    def mkEarlyDef(defn: Tree): Tree
+
+    def mkEarlyDef(defns: List[Tree]): List[Tree]
+
+    def RefTree(qual: Tree, sym: Symbol): Tree
+
+    def freshTermName(prefix: String): TermName
+
+    def freshTypeName(prefix: String): TypeName
+
+    val ImplicitParams: ImplicitParamsExtractor
+
+    trait ImplicitParamsExtractor {
+      def apply(paramss: List[List[ValDef]], implparams: List[ValDef]): List[List[ValDef]]
+      def unapply(vparamss: List[List[ValDef]]): Some[(List[List[ValDef]], List[ValDef])]
+    }
+
+    val ScalaDot: ScalaDotExtractor
+
+    trait ScalaDotExtractor {
+      def apply(name: Name): Tree
+      def unapply(tree: Tree): Option[Name]
+    }
+
+    val FlagsRepr: FlagsReprExtractor
+
+    trait FlagsReprExtractor {
+      def apply(value: Long): FlagSet
+      def unapply(flags: Long): Some[Long]
+    }
+
+    val SyntacticTypeApplied: SyntacticTypeAppliedExtractor
+
+    trait SyntacticTypeAppliedExtractor {
+      def apply(tree: Tree, targs: List[Tree]): Tree
+      def unapply(tree: Tree): Some[(Tree, List[Tree])]
+    }
+
+    val SyntacticApplied: SyntacticAppliedExtractor
+
+    trait SyntacticAppliedExtractor {
+      def apply(tree: Tree, argss: List[List[Tree]]): Tree
+      def unapply(tree: Tree): Some[(Tree, List[List[Tree]])]
+    }
+
+    val SyntacticClassDef: SyntacticClassDefExtractor
+
+    trait SyntacticClassDefExtractor {
+      def apply(mods: Modifiers, name: TypeName, tparams: List[Tree],
+                constrMods: Modifiers, vparamss: List[List[Tree]],
+                earlyDefs: List[Tree], parents: List[Tree], selfType: Tree, body: List[Tree]): ClassDef
+      def unapply(tree: Tree): Option[(Modifiers, TypeName, List[TypeDef], Modifiers, List[List[ValDef]],
+                                       List[Tree], List[Tree], ValDef, List[Tree])]
+    }
+
+    val SyntacticTraitDef: SyntacticTraitDefExtractor
+
+    trait SyntacticTraitDefExtractor {
+      def apply(mods: Modifiers, name: TypeName, tparams: List[Tree],
+                earlyDefs: List[Tree], parents: List[Tree], selfType: Tree, body: List[Tree]): ClassDef
+      def unapply(tree: Tree): Option[(Modifiers, TypeName, List[TypeDef],
+                                       List[Tree], List[Tree], ValDef, List[Tree])]
+    }
+
+    val SyntacticObjectDef: SyntacticObjectDefExtractor
+
+    trait SyntacticObjectDefExtractor {
+      def apply(mods: Modifiers, name: TermName, earlyDefs: List[Tree],
+                parents: List[Tree], selfType: Tree, body: List[Tree]): ModuleDef
+      def unapply(tree: Tree): Option[(Modifiers, TermName, List[Tree], List[Tree], ValDef, List[Tree])]
+    }
+
+    val SyntacticPackageObjectDef: SyntacticPackageObjectDefExtractor
+
+    trait SyntacticPackageObjectDefExtractor {
+      def apply(name: TermName, earlyDefs: List[Tree],
+                parents: List[Tree], selfType: Tree, body: List[Tree]): PackageDef
+      def unapply(tree: Tree): Option[(TermName, List[Tree], List[Tree], ValDef, List[Tree])]
+    }
+
+    val SyntacticTuple: SyntacticTupleExtractor
+    val SyntacticTupleType: SyntacticTupleExtractor
+
+    trait SyntacticTupleExtractor {
+      def apply(args: List[Tree]): Tree
+      def unapply(tree: Tree): Option[List[Tree]]
+    }
+
+    val SyntacticBlock: SyntacticBlockExtractor
+
+    trait SyntacticBlockExtractor {
+      def apply(stats: List[Tree]): Tree
+      def unapply(tree: Tree): Option[List[Tree]]
+    }
+
+    val SyntacticNew: SyntacticNewExtractor
+
+    trait SyntacticNewExtractor {
+      def apply(earlyDefs: List[Tree], parents: List[Tree], selfType: Tree, body: List[Tree]): Tree
+      def unapply(tree: Tree): Option[(List[Tree], List[Tree], ValDef, List[Tree])]
+    }
+
+    val SyntacticFunctionType: SyntacticFunctionTypeExtractor
+
+    trait SyntacticFunctionTypeExtractor {
+      def apply(argtpes: List[Tree], restpe: Tree): Tree
+      def unapply(tree: Tree): Option[(List[Tree], Tree)]
+    }
+
+    val SyntacticFunction: SyntacticFunctionExtractor
+
+    trait SyntacticFunctionExtractor {
+      def apply(params: List[Tree], body: Tree): Function
+
+      def unapply(tree: Function): Option[(List[ValDef], Tree)]
+    }
+
+    val SyntacticDefDef: SyntacticDefDefExtractor
+
+    trait SyntacticDefDefExtractor {
+      def apply(mods: Modifiers, name: TermName, tparams: List[Tree],
+                vparamss: List[List[Tree]], tpt: Tree, rhs: Tree): DefDef
+
+      def unapply(tree: Tree): Option[(Modifiers, TermName, List[TypeDef], List[List[ValDef]], Tree, Tree)]
+    }
+
+    val SyntacticValDef: SyntacticValDefExtractor
+    val SyntacticVarDef: SyntacticValDefExtractor
+
+    trait SyntacticValDefExtractor {
+      def apply(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree): ValDef
+      def unapply(tree: Tree): Option[(Modifiers, TermName, Tree, Tree)]
+    }
+
+    val SyntacticAssign: SyntacticAssignExtractor
+
+    trait SyntacticAssignExtractor {
+      def apply(lhs: Tree, rhs: Tree): Tree
+      def unapply(tree: Tree): Option[(Tree, Tree)]
+    }
+
+    val SyntacticValFrom: SyntacticValFromExtractor
+
+    trait SyntacticValFromExtractor {
+      def apply(pat: Tree, rhs: Tree): Tree
+      def unapply(tree: Tree): Option[(Tree, Tree)]
+    }
+
+    val SyntacticValEq: SyntacticValEqExtractor
+
+    trait SyntacticValEqExtractor {
+      def apply(pat: Tree, rhs: Tree): Tree
+      def unapply(tree: Tree): Option[(Tree, Tree)]
+    }
+
+    val SyntacticFilter: SyntacticFilterExtractor
+
+    trait SyntacticFilterExtractor {
+      def apply(test: Tree): Tree
+      def unapply(tree: Tree): Option[(Tree)]
+    }
+
+    val SyntacticEmptyTypeTree: SyntacticEmptyTypeTreeExtractor
+
+    trait SyntacticEmptyTypeTreeExtractor {
+      def apply(): TypeTree
+      def unapply(tt: TypeTree): Boolean
+    }
+
+    val SyntacticFor: SyntacticForExtractor
+    val SyntacticForYield: SyntacticForExtractor
+
+    trait SyntacticForExtractor {
+      def apply(enums: List[Tree], body: Tree): Tree
+      def unapply(tree: Tree): Option[(List[Tree], Tree)]
+    }
+
+    def UnliftListElementwise[T](unliftable: Unliftable[T]): UnliftListElementwise[T]
+    trait UnliftListElementwise[T] {
+      def unapply(lst: List[Tree]): Option[List[T]]
+    }
+
+    def UnliftListOfListsElementwise[T](unliftable: Unliftable[T]): UnliftListOfListsElementwise[T]
+    trait UnliftListOfListsElementwise[T] {
+      def unapply(lst: List[List[Tree]]): Option[List[List[T]]]
+    }
+
+    val SyntacticMatch: SyntacticMatchExtractor
+    trait SyntacticMatchExtractor {
+      def apply(selector: Tree, cases: List[Tree]): Match
+      def unapply(tree: Match): Option[(Tree, List[CaseDef])]
+    }
+
+    val SyntacticTry: SyntacticTryExtractor
+    trait SyntacticTryExtractor {
+      def apply(block: Tree, catches: List[Tree], finalizer: Tree): Try
+      def unapply(tree: Try): Option[(Tree, List[CaseDef], Tree)]
+    }
+
+    val SyntacticIdent: SyntacticIdentExtractor
+    trait SyntacticIdentExtractor {
+      def apply(name: Name, isBackquoted: Boolean = false): Ident
+      def unapply(tree: Ident): Option[(Name, Boolean)]
+    }
+
+    val SyntacticImport: SyntacticImportExtractor
+    trait SyntacticImportExtractor {
+      def apply(expr: Tree, selectors: List[Tree]): Import
+      def unapply(imp: Import): Some[(Tree, List[Tree])]
+    }
+  }
+
+  /** This trait provides support for importers, a facility to migrate reflection artifacts between universes.
+   * ''Note: this trait should typically be used only rarely.''
+   *
+   *  Reflection artifacts, such as [[scala.reflect.api.Symbols Symbols]] and [[scala.reflect.api.Types Types]],
+   *  are contained in [[scala.reflect.api.Universe Universe]]s. Typically all processing happens
+   *  within a single `Universe` (e.g. a compile-time macro `Universe` or a runtime reflection `Universe`), but sometimes
+   *  there is a need to migrate artifacts from one `Universe` to another. For example, runtime compilation works by
+   *  importing runtime reflection trees into a runtime compiler universe, compiling the importees and exporting the
+   *  result back.
+   *
+   *  Reflection artifacts are firmly grounded in their `Universe`s, which is reflected by the fact that types of artifacts
+   *  from different universes are not compatible. By using `Importer`s, however, they be imported from one universe
+   *  into another. For example, to import `foo.bar.Baz` from the source `Universe` to the target `Universe`,
+   *  an importer will first check whether the entire owner chain exists in the target `Universe`.
+   *  If it does, then nothing else will be done. Otherwise, the importer will recreate the entire owner chain
+   *  and will import the corresponding type signatures into the target `Universe`.
+   *
+   *  Since importers match `Symbol` tables of the source and the target `Universe`s using plain string names,
+   *  it is programmer's responsibility to make sure that imports don't distort semantics, e.g., that
+   *  `foo.bar.Baz` in the source `Universe` means the same that `foo.bar.Baz` does in the target `Universe`.
+   *
+   *  === Example ===
+   *
+   *  Here's how one might implement a macro that performs compile-time evaluation of its argument
+   *  by using a runtime compiler to compile and evaluate a tree that belongs to a compile-time compiler:
+   *
+   *  {{{
+   *  def staticEval[T](x: T) = macro staticEval[T]
+   *
+   *  def staticEval[T](c: scala.reflect.macros.blackbox.Context)(x: c.Expr[T]) = {
+   *    // creates a runtime reflection universe to host runtime compilation
+   *    import scala.reflect.runtime.{universe => ru}
+   *    val mirror = ru.runtimeMirror(c.libraryClassLoader)
+   *    import scala.tools.reflect.ToolBox
+   *    val toolBox = mirror.mkToolBox()
+   *
+   *    // runtime reflection universe and compile-time macro universe are different
+   *    // therefore an importer is needed to bridge them
+   *    // currently mkImporter requires a cast to correctly assign the path-dependent types
+   *    val importer0 = ru.internal.mkImporter(c.universe)
+   *    val importer = importer0.asInstanceOf[ru.internal.Importer { val from: c.universe.type }]
+   *
+   *    // the created importer is used to turn a compiler tree into a runtime compiler tree
+   *    // both compilers use the same classpath, so semantics remains intact
+   *    val imported = importer.importTree(tree)
+   *
+   *    // after the tree is imported, it can be evaluated as usual
+   *    val tree = toolBox.untypecheck(imported.duplicate)
+   *    val valueOfX = toolBox.eval(imported).asInstanceOf[T]
+   *    ...
+   *  }
+   *  }}}
+   *
+   *  @group Internal
+   */
+  // SI-6241: move importers to a mirror
+  trait Importer {
+    /** The source universe of reflection artifacts that will be processed.
+     *  The target universe is universe that created this importer with `mkImporter`.
+     */
+    val from: Universe
+
+    /** An importer that works in reverse direction, namely:
+     *  imports reflection artifacts from the current universe to the universe specified in `from`.
+     */
+    val reverse: from.Importer { val from: self.type }
+
+    /** In the current universe, locates or creates a symbol that corresponds to the provided symbol in the source universe.
+     *  If necessary imports the owner chain, companions, type signature, annotations and attachments.
+     */
+    def importSymbol(sym: from.Symbol): Symbol
+
+    /** In the current universe, locates or creates a type that corresponds to the provided type in the source universe.
+     *  If necessary imports the underlying symbols, annotations, scopes and trees.
+     */
+    def importType(tpe: from.Type): Type
+
+    /** In the current universe, creates a tree that corresponds to the provided tree in the source universe.
+     *  If necessary imports the underlying symbols, types and attachments.
+     */
+    def importTree(tree: from.Tree): Tree
+
+    /** In the current universe, creates a position that corresponds to the provided position in the source universe.
+     */
+    def importPosition(pos: from.Position): Position
+  }
+
+  /** Marks underlying reference to id as boxed.
+   *
+   *  <b>Precondition:<\b> id must refer to a captured variable
+   *  A reference such marked will refer to the boxed entity, no dereferencing
+   *  with `.elem` is done on it.
+   *  This tree node can be emitted by macros such as reify that call referenceCapturedVariable.
+   *  It is eliminated in LambdaLift, where the boxing conversion takes place.
+   *  @group Internal
+   *  @template
+   */
+  type ReferenceToBoxed >: Null <: ReferenceToBoxedApi with TermTree
+
+  /** The constructor/extractor for `ReferenceToBoxed` instances.
+   *  @group Internal
+   */
+  val ReferenceToBoxed: ReferenceToBoxedExtractor
+
+  /** An extractor class to create and pattern match with syntax `ReferenceToBoxed(ident)`.
+   *  This AST node does not have direct correspondence to Scala code,
+   *  and is emitted by macros to reference capture vars directly without going through `elem`.
+   *
+   *  For example:
+   *
+   *    var x = ...
+   *    fun { x }
+   *
+   *  Will emit:
+   *
+   *    Ident(x)
+   *
+   *  Which gets transformed to:
+   *
+   *    Select(Ident(x), "elem")
+   *
+   *  If `ReferenceToBoxed` were used instead of Ident, no transformation would be performed.
+   *  @group Internal
+   */
+  abstract class ReferenceToBoxedExtractor {
+    def apply(ident: Ident): ReferenceToBoxed
+    def unapply(referenceToBoxed: ReferenceToBoxed): Option[Ident]
+  }
+
+  /** The API that all references support
+   *  @group Internal
+   */
+  trait ReferenceToBoxedApi extends TermTreeApi { this: ReferenceToBoxed =>
+    /** The underlying reference. */
+    def ident: Tree
+  }
+
+  /** Tag that preserves the identity of `ReferenceToBoxed` in the face of erasure.
+   *  Can be used for pattern matching, instance tests, serialization and the like.
+   *  @group Internal
+   */
+  implicit val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]
+
+  /** The type of free terms introduced by reification.
+   *  @group Internal
+   *  @template
+   */
+  type FreeTermSymbol >: Null <: FreeTermSymbolApi with TermSymbol
+
+  /** The API of free term symbols.
+   *  The main source of information about symbols is the [[Symbols]] page.
+   *
+   *  $SYMACCESSORS
+   *  @group Internal
+   */
+  trait FreeTermSymbolApi extends TermSymbolApi { this: FreeTermSymbol =>
+    /** The place where this symbol has been spawned
+     *
+     *  @group FreeTerm
+     */
+    def origin: String
+
+    /** The valus this symbol refers to
+     *
+     *  @group FreeTerm
+     */
+    def value: Any
+  }
+
+  /** Tag that preserves the identity of `FreeTermSymbol` in the face of erasure.
+   *  Can be used for pattern matching, instance tests, serialization and the like.
+   *  @group Internal
+   */
+  implicit val FreeTermSymbolTag: ClassTag[FreeTermSymbol]
+
+  /** The type of free types introduced by reification.
+   *  @group Internal
+   *  @template
+   */
+  type FreeTypeSymbol >: Null <: FreeTypeSymbolApi with TypeSymbol
+
+  /** The API of free type symbols.
+   *  The main source of information about symbols is the [[Symbols]] page.
+   *
+   *  $SYMACCESSORS
+   *  @group Internal
+   */
+  trait FreeTypeSymbolApi extends TypeSymbolApi { this: FreeTypeSymbol =>
+    /** The place where this symbol has been spawned
+     *
+     *  @group FreeType
+     */
+    def origin: String
+  }
+
+  /** Tag that preserves the identity of `FreeTermSymbol` in the face of erasure.
+   *  Can be used for pattern matching, instance tests, serialization and the like.
+   *  @group Internal
+   */
+  implicit val FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]
+}
diff --git a/src/reflect/scala/reflect/api/JavaMirrors.scala b/src/reflect/scala/reflect/api/JavaMirrors.scala
deleted file mode 100644
index 05a4a61d2e..0000000000
--- a/src/reflect/scala/reflect/api/JavaMirrors.scala
+++ /dev/null
@@ -1,58 +0,0 @@
-package scala
-package reflect
-package api
-
-/**
- * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
- *
- * A refinement of [[scala.reflect.api.Mirror]] for runtime reflection using JVM classloaders.
- *
- *  This refinement equips mirrors with reflection capabilities for the JVM. `JavaMirror` can
- *  convert Scala reflection artifacts (symbols and types) into Java reflection artifacts (classes)
- *  and vice versa. It can also perform reflective invocations (getting/setting field values,
- *  calling methods, etc).
- *
- *  For more information about `Mirrors`s, see [[scala.reflect.api.Mirrors]] or the
- *  [[http://docs.scala-lang.org/overviews/reflection/environment-universes-mirrors.html Reflection Guide: Mirrors]]
- *
- *  @groupname JavaMirrors Java Mirrors
- *  @group ReflectionAPI
- */
-trait JavaMirrors { self: JavaUniverse =>
-
-  /** In runtime reflection universes, runtime representation of a class is `java.lang.Class`.
-   *  @group JavaMirrors
-   */
-  type RuntimeClass = java.lang.Class[_]
-  implicit val RuntimeClassTag: ClassTag[RuntimeClass] = ClassTag[RuntimeClass](classOf[RuntimeClass])
-
-  /** In runtime reflection universes, mirrors are `JavaMirrors`.
-   *  @group JavaMirrors
-   */
-  override type Mirror >: Null <: JavaMirror
-
-  /** A refinement of [[scala.reflect.api.Mirror]] for runtime reflection using JVM classloaders.
-   *
-   *  With this upgrade, mirrors become capable of converting Scala reflection artifacts (symbols and types)
-   *  into Java reflection artifacts (classes) and vice versa. Consequently, refined mirrors
-   *  become capable of performing reflective invocations (getting/setting field values, calling methods, etc).
-   *
-   *  For more information about `Mirrors`s, see [[scala.reflect.api.Mirrors]] or the
-   * [[http://docs.scala-lang.org/overviews/reflection/environment-universes-mirrors.html Reflection Guide: Mirrors]]
-   *
-   *  @group JavaMirrors
-   */
-  trait JavaMirror extends scala.reflect.api.Mirror[self.type] with RuntimeMirror {
-    val classLoader: ClassLoader
-    override def toString = s"JavaMirror with ${runtime.ReflectionUtils.show(classLoader)}"
-  }
-
-  /** Creates a runtime reflection mirror from a JVM classloader.
-   *
-   *  For more information about `Mirrors`s, see [[scala.reflect.api.Mirrors]] or the
-   * [[http://docs.scala-lang.org/overviews/reflection/environment-universes-mirrors.html Reflection Guide: Mirrors]]
-   *
-   *  @group JavaMirrors
-   */
-  def runtimeMirror(cl: ClassLoader): Mirror
-}
diff --git a/src/reflect/scala/reflect/api/JavaUniverse.scala b/src/reflect/scala/reflect/api/JavaUniverse.scala
index df5e0699a5..88107ea117 100644
--- a/src/reflect/scala/reflect/api/JavaUniverse.scala
+++ b/src/reflect/scala/reflect/api/JavaUniverse.scala
@@ -3,12 +3,14 @@ package reflect
 package api
 
 /**
- * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
+ *  <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
  *
- * A refinement of [[scala.reflect.api.Universe]] for runtime reflection using JVM classloaders.
+ *  A refinement of [[scala.reflect.api.Universe]] for runtime reflection using JVM classloaders.
  *
- *  The refinement consists of an upgrade to the mirror API, which gets extended from [[scala.reflect.api.Mirror]]
- *  to [[scala.reflect.api.JavaMirrors#JavaMirror]].
+ *  This refinement equips mirrors with reflection capabilities for the JVM. `JavaMirror` can
+ *  convert Scala reflection artifacts (symbols and types) into Java reflection artifacts (classes)
+ *  and vice versa. It can also perform reflective invocations (getting/setting field values,
+ *  calling methods, etc).
  *
  *  See the [[http://docs.scala-lang.org/overviews/reflection/overview.html Reflection Guide]] for details on how to use runtime reflection.
  *
@@ -17,31 +19,41 @@ package api
  *
  *  @contentDiagram hideNodes "*Api"
  */
-trait JavaUniverse extends Universe with JavaMirrors { self =>
+trait JavaUniverse extends Universe { self =>
 
-  /*  @group JavaUniverse */
-  override def typeTagToManifest[T: ClassTag](mirror0: Any, tag: Universe # TypeTag[T]): Manifest[T] = {
-    // SI-6239: make this conversion more precise
-    val mirror = mirror0.asInstanceOf[Mirror]
-    val runtimeClass = mirror.runtimeClass(tag.in(mirror).tpe)
-    Manifest.classType(runtimeClass).asInstanceOf[Manifest[T]]
+  /** In runtime reflection universes, runtime representation of a class is `java.lang.Class`.
+   *  @group JavaMirrors
+   */
+  type RuntimeClass = java.lang.Class[_]
+  implicit val RuntimeClassTag: ClassTag[RuntimeClass] = ClassTag[RuntimeClass](classOf[RuntimeClass])
+
+  /** In runtime reflection universes, mirrors are `JavaMirrors`.
+   *  @group JavaMirrors
+   */
+  override type Mirror >: Null <: JavaMirror
+
+  /** A refinement of [[scala.reflect.api.Mirror]] for runtime reflection using JVM classloaders.
+   *
+   *  With this upgrade, mirrors become capable of converting Scala reflection artifacts (symbols and types)
+   *  into Java reflection artifacts (classes) and vice versa. Consequently, refined mirrors
+   *  become capable of performing reflective invocations (getting/setting field values, calling methods, etc).
+   *
+   *  For more information about `Mirrors`s, see [[scala.reflect.api.Mirrors]] or the
+   * [[http://docs.scala-lang.org/overviews/reflection/environment-universes-mirrors.html Reflection Guide: Mirrors]]
+   *
+   *  @group JavaMirrors
+   */
+  trait JavaMirror extends scala.reflect.api.Mirror[self.type] with RuntimeMirror {
+    val classLoader: ClassLoader
+    override def toString = s"JavaMirror with ${runtime.ReflectionUtils.show(classLoader)}"
   }
 
-  /*  @group JavaUniverse */
-  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: scala.reflect.api.Mirror[U]): U # Type = {
-        mirror.universe match {
-          case ju: JavaUniverse =>
-            val jm = mirror.asInstanceOf[ju.Mirror]
-            val sym = jm.classSymbol(manifest.runtimeClass)
-            val tpe =
-              if (manifest.typeArguments.isEmpty) sym.toType
-              else ju.appliedType(sym.toTypeConstructor, manifest.typeArguments map (targ => ju.manifestToTypeTag(jm, targ)) map (_.in(jm).tpe))
-            tpe.asInstanceOf[U # Type]
-          case u =>
-            u.manifestToTypeTag(mirror.asInstanceOf[u.Mirror], manifest).in(mirror).tpe
-        }
-      }
-    })
-}
+  /** Creates a runtime reflection mirror from a JVM classloader.
+   *
+   *  For more information about `Mirrors`s, see [[scala.reflect.api.Mirrors]] or the
+   * [[http://docs.scala-lang.org/overviews/reflection/environment-universes-mirrors.html Reflection Guide: Mirrors]]
+   *
+   *  @group JavaMirrors
+   */
+  def runtimeMirror(cl: ClassLoader): Mirror
+}
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/api/Mirrors.scala b/src/reflect/scala/reflect/api/Mirrors.scala
index 0d39f628ce..f688001f95 100644
--- a/src/reflect/scala/reflect/api/Mirrors.scala
+++ b/src/reflect/scala/reflect/api/Mirrors.scala
@@ -62,7 +62,7 @@ package api
  * The entry point to `Mirror`s for use at runtime is via `ru.runtimeMirror(<classloader>)`, where
  * `ru` is [[scala.reflect.runtime.universe]].
  *
- * The result of a [[scala.reflect.api.JavaMirrors#runtimeMirror]] call is a classloader mirror,
+ * The result of a [[scala.reflect.api.JavaUniverse#runtimeMirror]] call is a classloader mirror,
  * of type [[scala.reflect.api.Mirrors#ReflectiveMirror]], which can load symbols by names as
  * discussed above (in the “Compile-time” section).
  *
diff --git a/src/reflect/scala/reflect/api/Scopes.scala b/src/reflect/scala/reflect/api/Scopes.scala
index 9327fb9762..3f926d68f2 100644
--- a/src/reflect/scala/reflect/api/Scopes.scala
+++ b/src/reflect/scala/reflect/api/Scopes.scala
@@ -34,11 +34,6 @@ trait Scopes { self: Universe =>
    */
   trait ScopeApi extends Iterable[Symbol]
 
-  /** Create a new scope with the given initial elements.
-   *  @group Scopes
-   */
-  def newScopeWith(elems: Symbol*): Scope
-
   /** The type of member scopes, as in class definitions, for example.
    *  @template
    *  @group Scopes
diff --git a/src/reflect/scala/reflect/api/StandardLiftables.scala b/src/reflect/scala/reflect/api/StandardLiftables.scala
index 104215bb93..6fc00de3e5 100644
--- a/src/reflect/scala/reflect/api/StandardLiftables.scala
+++ b/src/reflect/scala/reflect/api/StandardLiftables.scala
@@ -2,7 +2,8 @@ package scala.reflect
 package api
 
 trait StandardLiftables { self: Universe =>
-  import build.{SyntacticTuple, ScalaDot}
+  import internal._
+  import reificationSupport.{SyntacticTuple, ScalaDot}
 
   trait StandardLiftableInstances {
     private def lift[T: Liftable](value: T): Tree            = implicitly[Liftable[T]].apply(value)
diff --git a/src/reflect/scala/reflect/api/Symbols.scala b/src/reflect/scala/reflect/api/Symbols.scala
index 9831420749..b30c6de01d 100644
--- a/src/reflect/scala/reflect/api/Symbols.scala
+++ b/src/reflect/scala/reflect/api/Symbols.scala
@@ -94,18 +94,6 @@ trait Symbols { self: Universe =>
    */
   type ClassSymbol >: Null <: ClassSymbolApi with TypeSymbol
 
-  /** The type of free terms introduced by reification.
-   *  @group Symbols
-   *  @template
-   */
-  type FreeTermSymbol >: Null <: FreeTermSymbolApi with TermSymbol
-
-  /** The type of free types introduced by reification.
-   *  @group Symbols
-   *  @template
-   */
-  type FreeTypeSymbol >: Null <: FreeTypeSymbolApi with TypeSymbol
-
   /** A special "missing" symbol. Commonly used in the API to denote a default or empty value.
    *  @group Symbols
    *  @template
@@ -131,12 +119,8 @@ trait Symbols { self: Universe =>
    *  @groupdesc Helpers       These methods enable collections-like operations on symbols.
    *  @groupname Type          TypeSymbol Members
    *  @groupprio Type          -1
-   *  @groupname FreeType      FreeType Symbol Members
-   *  @groupprio FreeType      -2
    *  @groupname Term          TermSymbol Members
    *  @groupprio Term          -1
-   *  @groupname FreeTerm      FreeTerm Symbol Members
-   *  @groupprio FreeTerm      -2
    *  @groupname Class         Class Symbol Members
    *  @groupprio Class         -2
    *  @groupname Method        Method Symbol Members
@@ -275,45 +259,6 @@ trait Symbols { self: Universe =>
      */
     def asClass: ClassSymbol = throw new ScalaReflectionException(s"$this is not a class")
 
-    /** Does this symbol represent a free term captured by reification?
-     *  If yes, `isTerm` is also guaranteed to be true.
-     *
-     *  @group Tests
-     */
-    def isFreeTerm: Boolean = false
-
-    /** This symbol cast to a free term symbol.
-     *  @throws ScalaReflectionException if `isFreeTerm` is false.
-     *
-     *  @group Conversions
-     */
-    def asFreeTerm: FreeTermSymbol = throw new ScalaReflectionException(s"$this is not a free term")
-
-    /** Does this symbol represent a free type captured by reification?
-     *  If yes, `isType` is also guaranteed to be true.
-     *
-     *  @group Tests
-     */
-    def isFreeType: Boolean = false
-
-    /** This symbol cast to a free type symbol.
-     *  @throws ScalaReflectionException if `isFreeType` is false.
-     *
-     *  @group Conversions
-     */
-    def asFreeType: FreeTypeSymbol = throw new ScalaReflectionException(s"$this is not a free type")
-
-    /** @group Constructors */
-    def newTermSymbol(name: TermName, pos: Position = NoPosition, flags: FlagSet = NoFlags): TermSymbol
-    /** @group Constructors */
-    def newModuleAndClassSymbol(name: Name, pos: Position = NoPosition, flags: FlagSet = NoFlags): (ModuleSymbol, ClassSymbol)
-    /** @group Constructors */
-    def newMethodSymbol(name: TermName, pos: Position = NoPosition, flags: FlagSet = NoFlags): MethodSymbol
-    /** @group Constructors */
-    def newTypeSymbol(name: TypeName, pos: Position = NoPosition, flags: FlagSet = NoFlags): TypeSymbol
-    /** @group Constructors */
-    def newClassSymbol(name: TypeName, pos: Position = NoPosition, flags: FlagSet = NoFlags): ClassSymbol
-
     /** 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.
      *
@@ -470,12 +415,6 @@ trait Symbols { self: Universe =>
      */
     def isPackageClass: Boolean
 
-    /** Does this symbol or its underlying type represent a typechecking error?
-     *
-     *  @group Tests
-     */
-    def isErroneous : Boolean
-
     /** Is this symbol static (i.e. with no outer instance)?
      *  Q: When exactly is a sym marked as STATIC?
      *  A: If it's a member of a toplevel object, or of an object contained in a toplevel object, or any number of levels deep.
@@ -743,13 +682,6 @@ trait Symbols { self: Universe =>
      */
     def isCovariant     : Boolean
 
-    /** Does this symbol represent the definition of a skolem?
-     *  Skolems are used during typechecking to represent type parameters viewed from inside their scopes.
-     *
-     *  @group Type
-     */
-    def isSkolem       : Boolean
-
     /** Does this symbol represent the definition of a type alias?
      *
      *  @group Type
@@ -952,6 +884,12 @@ trait Symbols { self: Universe =>
      */
     def thisPrefix: Type
 
+    /** The type `C.super[M]`, where `C` is the current class and `M` is supertpe.
+     *
+     *  @group Class
+     */
+    def superPrefix(supertpe: Type): Type
+
     /** For a polymorphic class/trait, its type parameters, the empty list for all other classes/trait
      *
      *  @group Class
@@ -971,44 +909,4 @@ trait Symbols { self: Universe =>
     // as at the moment we don't have time or risk tolerance for that
     def primaryConstructor: Symbol
   }
-
-  /** The API of free term symbols.
-   *  The main source of information about symbols is the [[Symbols]] page.
-   *
-   *  $SYMACCESSORS
-   *  @group API
-   */
-  trait FreeTermSymbolApi extends TermSymbolApi { this: FreeTermSymbol =>
-    final override def isFreeTerm = true
-    final override def asFreeTerm = this
-
-    /** The place where this symbol has been spawned
-     *
-     *  @group FreeTerm
-     */
-    def origin: String
-
-    /** The valus this symbol refers to
-     *
-     *  @group FreeTerm
-     */
-    def value: Any
-  }
-
-  /** The API of free type symbols.
-   *  The main source of information about symbols is the [[Symbols]] page.
-   *
-   *  $SYMACCESSORS
-   *  @group API
-   */
-  trait FreeTypeSymbolApi extends TypeSymbolApi { this: FreeTypeSymbol =>
-    final override def isFreeType = true
-    final override def asFreeType = this
-
-    /** The place where this symbol has been spawned
-     *
-     *  @group FreeType
-     */
-    def origin: String
-  }
 }
diff --git a/src/reflect/scala/reflect/api/TagInterop.scala b/src/reflect/scala/reflect/api/TagInterop.scala
deleted file mode 100644
index 51b7c519c5..0000000000
--- a/src/reflect/scala/reflect/api/TagInterop.scala
+++ /dev/null
@@ -1,44 +0,0 @@
-package scala
-package reflect
-package api
-
-/**
- * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
- *
- *  This trait provides type tag <-> manifest interoperability.
- *  @group ReflectionAPI
- *
- *  @groupname TagInterop TypeTag and Manifest Interoperability
- */
-trait TagInterop { self: Universe =>
-  // TODO `mirror` parameters are now of type `Any`, because I can't make these path-dependent types work
-  // if you're brave enough, replace `Any` with `Mirror`, recompile and run interop_typetags_are_manifests.scala
-
-  /**
-   * Convert a [[scala.reflect.api.TypeTags#TypeTag]] to a [[scala.reflect.Manifest]].
-   *
-   * Compiler usually generates these conversions automatically, when a type tag for a type `T` is in scope,
-   * and an implicit of type `Manifest[T]` is requested, but this method can also be called manually.
-   * For example:
-   * {{{
-   * typeTagToManifest(scala.reflect.runtime.currentMirror, implicitly[TypeTag[String]])
-   * }}}
-   * @group TagInterop
-   */
-  def typeTagToManifest[T: ClassTag](mirror: Any, tag: Universe#TypeTag[T]): Manifest[T] =
-    throw new UnsupportedOperationException("This universe does not support tag -> manifest conversions. Use a JavaUniverse, e.g. the scala.reflect.runtime.universe.")
-
-  /**
-   * Convert a [[scala.reflect.Manifest]] to a [[scala.reflect.api.TypeTags#TypeTag]].
-   *
-   * Compiler usually generates these conversions automatically, when a manifest for a type `T` is in scope,
-   * and an implicit of type `TypeTag[T]` is requested, but this method can also be called manually.
-   * For example:
-   * {{{
-   * manifestToTypeTag(scala.reflect.runtime.currentMirror, implicitly[Manifest[String]])
-   * }}}
-   * @group TagInterop
-   */
-  def manifestToTypeTag[T](mirror: Any, manifest: Manifest[T]): Universe#TypeTag[T] =
-    throw new UnsupportedOperationException("This universe does not support manifest -> tag conversions. Use a JavaUniverse, e.g. the scala.reflect.runtime.universe.")
-}
diff --git a/src/reflect/scala/reflect/api/Trees.scala b/src/reflect/scala/reflect/api/Trees.scala
index 45d28e3e5a..a42f6ab728 100644
--- a/src/reflect/scala/reflect/api/Trees.scala
+++ b/src/reflect/scala/reflect/api/Trees.scala
@@ -168,29 +168,6 @@ trait Trees { self: Universe =>
      */
     def children: List[Tree]
 
-    /** Extracts free term symbols from a tree that is reified or contains reified subtrees.
-     */
-    def freeTerms: List[FreeTermSymbol]
-
-    /** Extracts free type symbols from a tree that is reified or contains reified subtrees.
-     */
-    def freeTypes: List[FreeTypeSymbol]
-
-    /** Substitute symbols in `to` for corresponding occurrences of references to
-     *  symbols `from` in this type.
-     */
-    def substituteSymbols(from: List[Symbol], to: List[Symbol]): Tree
-
-    /** Substitute types in `to` for corresponding occurrences of references to
-     *  symbols `from` in this tree.
-     */
-    def substituteTypes(from: List[Symbol], to: List[Type]): Tree
-
-    /** Substitute given tree `to` for occurrences of nodes that represent
-     *  `C.this`, where `C` referes to the given class `clazz`.
-     */
-    def substituteThis(clazz: Symbol, to: Tree): Tree
-
     /** Make a copy of this tree, keeping all attributes,
      *  except that all positions are focused (so nothing
      *  in this tree will be found when searching by position).
@@ -1745,60 +1722,13 @@ trait Trees { self: Universe =>
    *  @group API
    */
   trait IdentApi extends RefTreeApi { this: Ident =>
+    /** Was this ident created from a backquoted identifier? */
+    def isBackquoted: Boolean
+
     /** @inheritdoc */
     def name: Name
   }
 
-  /** Marks underlying reference to id as boxed.
-   *
-   *  <b>Precondition:<\b> id must refer to a captured variable
-   *  A reference such marked will refer to the boxed entity, no dereferencing
-   *  with `.elem` is done on it.
-   *  This tree node can be emitted by macros such as reify that call referenceCapturedVariable.
-   *  It is eliminated in LambdaLift, where the boxing conversion takes place.
-   *  @group Trees
-   *  @template
-   */
-  type ReferenceToBoxed >: Null <: ReferenceToBoxedApi with TermTree
-
-  /** The constructor/extractor for `ReferenceToBoxed` instances.
-   *  @group Extractors
-   */
-  val ReferenceToBoxed: ReferenceToBoxedExtractor
-
-  /** An extractor class to create and pattern match with syntax `ReferenceToBoxed(ident)`.
-   *  This AST node does not have direct correspondence to Scala code,
-   *  and is emitted by macros to reference capture vars directly without going through `elem`.
-   *
-   *  For example:
-   *
-   *    var x = ...
-   *    fun { x }
-   *
-   *  Will emit:
-   *
-   *    Ident(x)
-   *
-   *  Which gets transformed to:
-   *
-   *    Select(Ident(x), "elem")
-   *
-   *  If `ReferenceToBoxed` were used instead of Ident, no transformation would be performed.
-   *  @group Extractors
-   */
-  abstract class ReferenceToBoxedExtractor {
-    def apply(ident: Ident): ReferenceToBoxed
-    def unapply(referenceToBoxed: ReferenceToBoxed): Option[Ident]
-  }
-
-  /** The API that all references support
-   *  @group API
-   */
-  trait ReferenceToBoxedApi extends TermTreeApi { this: ReferenceToBoxed =>
-    /** The underlying reference. */
-    def ident: Tree
-  }
-
   /** Literal
    *  @group Trees
    *  @template
@@ -2140,78 +2070,6 @@ trait Trees { self: Universe =>
 
 // ---------------------- factories ----------------------------------------------
 
-  /** A factory method for `ClassDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical ClassDef constructor to create a class and then initialize its position and symbol manually", "2.10.1")
-  def ClassDef(sym: Symbol, impl: Template): ClassDef
-
-  /** A factory method for `ModuleDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical ModuleDef constructor to create an object and then initialize its position and symbol manually", "2.10.1")
-  def ModuleDef(sym: Symbol, impl: Template): ModuleDef
-
-  /** A factory method for `ValDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical ValDef constructor to create a val and then initialize its position and symbol manually", "2.10.1")
-  def ValDef(sym: Symbol, rhs: Tree): ValDef
-
-  /** A factory method for `ValDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical ValDef constructor to create a val with an empty right-hand side and then initialize its position and symbol manually", "2.10.1")
-  def ValDef(sym: Symbol): ValDef
-
-  /** A factory method for `ValDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical DefDef constructor to create a method and then initialize its position and symbol manually", "2.10.1")
-  def DefDef(sym: Symbol, mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree): DefDef
-
-  /** A factory method for `ValDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical DefDef constructor to create a method and then initialize its position and symbol manually", "2.10.1")
-  def DefDef(sym: Symbol, vparamss: List[List[ValDef]], rhs: Tree): DefDef
-
-  /** A factory method for `ValDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical DefDef constructor to create a method and then initialize its position and symbol manually", "2.10.1")
-  def DefDef(sym: Symbol, mods: Modifiers, rhs: Tree): DefDef
-
-  /** A factory method for `ValDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical DefDef constructor to create a method and then initialize its position and symbol manually", "2.10.1")
-  def DefDef(sym: Symbol, rhs: Tree): DefDef
-
-  /** A factory method for `ValDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical DefDef constructor to create a method and then initialize its position and symbol manually", "2.10.1")
-  def DefDef(sym: Symbol, rhs: List[List[Symbol]] => Tree): DefDef
-
-  /** A factory method for `TypeDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical TypeDef constructor to create a type alias and then initialize its position and symbol manually", "2.10.1")
-  def TypeDef(sym: Symbol, rhs: Tree): TypeDef
-
-  /** A factory method for `TypeDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical TypeDef constructor to create an abstract type or type parameter and then initialize its position and symbol manually", "2.10.1")
-  def TypeDef(sym: Symbol): TypeDef
-
-  /** A factory method for `LabelDef` nodes.
-   *  @group Factories
-   */
-  @deprecated("Use the canonical LabelDef constructor to create a label and then initialize its position and symbol manually", "2.10.1")
-  def LabelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef
-
   /** A factory method for `Block` nodes.
    *  Flattens directly nested blocks.
    *  @group Factories
diff --git a/src/reflect/scala/reflect/api/Types.scala b/src/reflect/scala/reflect/api/Types.scala
index 2900b7ab3d..dd63211c32 100644
--- a/src/reflect/scala/reflect/api/Types.scala
+++ b/src/reflect/scala/reflect/api/Types.scala
@@ -393,10 +393,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class ThisTypeExtractor {
-    /**
-     * Creates a ThisType from the given class symbol.
-     */
-    def apply(sym: Symbol): Type
     def unapply(tpe: ThisType): Option[Symbol]
   }
 
@@ -432,7 +428,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class SingleTypeExtractor {
-    def apply(pre: Type, sym: Symbol): Type // not SingleTypebecause of implementation details
     def unapply(tpe: SingleType): Option[(Type, Symbol)]
   }
 
@@ -469,7 +464,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class SuperTypeExtractor {
-    def apply(thistpe: Type, supertpe: Type): Type // not SuperTypebecause of implementation details
     def unapply(tpe: SuperType): Option[(Type, Type)]
   }
 
@@ -509,7 +503,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class ConstantTypeExtractor {
-    def apply(value: Constant): ConstantType
     def unapply(tpe: ConstantType): Option[Constant]
   }
 
@@ -549,7 +542,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class TypeRefExtractor {
-    def apply(pre: Type, sym: Symbol, args: List[Type]): Type // not TypeRefbecause of implementation details
     def unapply(tpe: TypeRef): Option[(Type, Symbol, List[Type])]
   }
 
@@ -606,12 +598,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class RefinedTypeExtractor {
-    def apply(parents: List[Type], decls: Scope): RefinedType
-
-    /** An alternative constructor that passes in the synthetic classs symbol
-     *  that backs the refined type. (Normally, a fresh class symbol is created automatically).
-     */
-    def apply(parents: List[Type], decls: Scope, clazz: Symbol): RefinedType
     def unapply(tpe: RefinedType): Option[(List[Type], Scope)]
   }
 
@@ -653,7 +639,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class ClassInfoTypeExtractor {
-    def apply(parents: List[Type], decls: Scope, typeSymbol: Symbol): ClassInfoType
     def unapply(tpe: ClassInfoType): Option[(List[Type], Scope, Symbol)]
   }
 
@@ -699,7 +684,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class MethodTypeExtractor {
-    def apply(params: List[Symbol], resultType: Type): MethodType
     def unapply(tpe: MethodType): Option[(List[Symbol], Type)]
   }
 
@@ -732,7 +716,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class NullaryMethodTypeExtractor {
-    def apply(resultType: Type): NullaryMethodType
     def unapply(tpe: NullaryMethodType): Option[(Type)]
   }
 
@@ -763,7 +746,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class PolyTypeExtractor {
-    def apply(typeParams: List[Symbol], resultType: Type): PolyType
     def unapply(tpe: PolyType): Option[(List[Symbol], Type)]
   }
 
@@ -798,7 +780,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class ExistentialTypeExtractor {
-    def apply(quantified: List[Symbol], underlying: Type): ExistentialType
     def unapply(tpe: ExistentialType): Option[(List[Symbol], Type)]
   }
 
@@ -833,7 +814,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class AnnotatedTypeExtractor {
-    def apply(annotations: List[Annotation], underlying: Type): AnnotatedType
     def unapply(tpe: AnnotatedType): Option[(List[Annotation], Type)]
   }
 
@@ -874,7 +854,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class TypeBoundsExtractor {
-    def apply(lo: Type, hi: Type): TypeBounds
     def unapply(tpe: TypeBounds): Option[(Type, Type)]
   }
 
@@ -924,7 +903,6 @@ trait Types {
    *  @group Extractors
    */
   abstract class BoundedWildcardTypeExtractor {
-    def apply(bounds: TypeBounds): BoundedWildcardType
     def unapply(tpe: BoundedWildcardType): Option[TypeBounds]
   }
 
@@ -947,74 +925,9 @@ trait Types {
    */
   def glb(ts: List[Type]): Type
 
-  // Creators ---------------------------------------------------------------
-  // too useful and too non-trivial to be left out of public API
-
-  /** The canonical creator for single-types
-   *  @group TypeCreators
-   */
-  def singleType(pre: Type, sym: Symbol): Type
-
-  /** the canonical creator for a refined type with a given scope
-   *  @group TypeCreators
-   */
-  def refinedType(parents: List[Type], owner: Symbol, decls: Scope, pos: Position): Type
-
-  /** The canonical creator for a refined type with an initially empty scope.
-   *  @group TypeCreators
-   */
-  def refinedType(parents: List[Type], owner: Symbol): Type
-
-  /** The canonical creator for typerefs
-   *  @group TypeCreators
-   */
-  def typeRef(pre: Type, sym: Symbol, args: List[Type]): Type
-
-  /** A creator for intersection type where intersections of a single type are
-   *  replaced by the type itself.
-   *  @group TypeCreators
-   */
-  def intersectionType(tps: List[Type]): Type
-
-  /** A creator for intersection type where intersections of a single type are
-   *  replaced by the type itself, and repeated parent classes are merged.
-   *
-   *  !!! Repeated parent classes are not merged - is this a bug in the
-   *  comment or in the code?
-   *  @group TypeCreators
-   */
-  def intersectionType(tps: List[Type], owner: Symbol): Type
-
   /** A creator for type applications
-   *  @group Types
+   *  @group TypeOps
    */
+  // TODO: needs a more convenient type signature, because applying types right now is quite boilerplatey
   def appliedType(tycon: Type, args: List[Type]): Type
-
-  /** A creator for type parameterizations that strips empty type parameter lists.
-   *  Use this factory method to indicate the type has kind * (it's a polymorphic value)
-   *  until we start tracking explicit kinds equivalent to typeFun (except that the latter requires tparams nonEmpty).
-   *  @group Types
-   */
-  def polyType(tparams: List[Symbol], tpe: Type): Type
-
-  /** A creator for existential types. This generates:
-   *
-   *  {{{
-   *    tpe1 where { tparams }
-   *  }}}
-   *
-   *  where `tpe1` is the result of extrapolating `tpe` with regard to `tparams`.
-   *  Extrapolating means that type variables in `tparams` occurring
-   *  in covariant positions are replaced by upper bounds, (minus any
-   *  SingletonClass markers), type variables in `tparams` occurring in
-   *  contravariant positions are replaced by upper bounds, provided the
-   *  resulting type is legal with regard to stability, and does not contain
-   *  any type variable in `tparams`.
-   *
-   *  The abstraction drops all type parameters that are not directly or
-   *  indirectly referenced by type `tpe1`. If there are no remaining type
-   *  parameters, simply returns result type `tpe`.
-   *  @group TypeCreators
-   */
-  def existentialAbstraction(tparams: List[Symbol], tpe0: Type): Type
 }
diff --git a/src/reflect/scala/reflect/api/Universe.scala b/src/reflect/scala/reflect/api/Universe.scala
index 85a8ee0185..a3d1d291eb 100644
--- a/src/reflect/scala/reflect/api/Universe.scala
+++ b/src/reflect/scala/reflect/api/Universe.scala
@@ -69,17 +69,15 @@ abstract class Universe extends Symbols
                            with Positions
                            with Exprs
                            with TypeTags
-                           with TagInterop
                            with ImplicitTags
                            with StandardDefinitions
                            with StandardNames
                            with StandardLiftables
-                           with BuildUtils
                            with Mirrors
                            with Printers
-                           with Importers
                            with Liftables
                            with Quasiquotes
+                           with Internals
 {
   /** Use `reify` to produce the abstract syntax tree representing a given Scala expression.
    *
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 645d6aa4ff..2567abe51d 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -461,6 +461,9 @@ trait Definitions extends api.StandardDefinitions {
          def ReflectRuntimeUniverse      = ReflectRuntimePackage.map(sym => getMemberValue(sym, nme.universe))
          def ReflectRuntimeCurrentMirror = ReflectRuntimePackage.map(sym => getMemberMethod(sym, nme.currentMirror))
 
+    lazy val UniverseClass    = getClassIfDefined("scala.reflect.api.Universe") // defined in scala-reflect.jar, so we need to be careful
+         def UniverseInternal = getMemberValue(UniverseClass, nme.internal)
+
     lazy val PartialManifestModule = requiredModule[scala.reflect.ClassManifestFactory.type]
     lazy val FullManifestClass     = requiredClass[scala.reflect.Manifest[_]]
     lazy val FullManifestModule    = requiredModule[scala.reflect.ManifestFactory.type]
diff --git a/src/reflect/scala/reflect/internal/Importers.scala b/src/reflect/scala/reflect/internal/Importers.scala
index ff91b08ea1..4e205a9a90 100644
--- a/src/reflect/scala/reflect/internal/Importers.scala
+++ b/src/reflect/scala/reflect/internal/Importers.scala
@@ -7,17 +7,7 @@ import scala.ref.WeakReference
 import scala.reflect.internal.Flags._
 
 // SI-6241: move importers to a mirror
-trait Importers extends api.Importers { to: SymbolTable =>
-
-  /** Attachment that knows how to import itself into another universe. */
-  trait ImportableAttachment {
-    def importAttachment(importer: Importer): this.type
-  }
-
-  /** Attachment that doesn't contain any reflection artificats and can be imported as-is. */
-  trait PlainAttachment extends ImportableAttachment {
-    def importAttachment(importer: Importer): this.type = this
-  }
+trait Importers { to: SymbolTable =>
 
   def mkImporter(from0: api.Universe): Importer { val from: from0.type } = (
     if (to eq from0) {
diff --git a/src/reflect/scala/reflect/internal/Internals.scala b/src/reflect/scala/reflect/internal/Internals.scala
new file mode 100644
index 0000000000..3c0d5ac263
--- /dev/null
+++ b/src/reflect/scala/reflect/internal/Internals.scala
@@ -0,0 +1,125 @@
+package scala
+package reflect
+package internal
+
+import scala.language.implicitConversions
+import scala.collection.mutable.WeakHashMap
+import scala.ref.WeakReference
+import scala.reflect.api.Universe
+import scala.reflect.macros.Attachments
+import scala.reflect.internal.util.FreshNameCreator
+import scala.reflect.internal.Flags._
+import scala.reflect.internal.util.ListOfNil
+
+trait Internals extends api.Internals {
+  self: SymbolTable =>
+
+  type Internal = MacroInternalApi
+  lazy val internal: Internal = new SymbolTableInternal {}
+
+  trait SymbolTableInternal extends MacroInternalApi {
+    lazy val reificationSupport: ReificationSupportApi = self.build
+
+    def createImporter(from0: Universe): Importer { val from: from0.type } = self.mkImporter(from0)
+
+    def newScopeWith(elems: Symbol*): Scope = self.newScopeWith(elems: _*)
+
+    def freeTerms(tree: Tree): List[FreeTermSymbol] = tree.freeTerms
+    def freeTypes(tree: Tree): List[FreeTypeSymbol] = tree.freeTypes
+    def substituteSymbols(tree: Tree, from: List[Symbol], to: List[Symbol]): Tree = tree.substituteSymbols(from, to)
+    def substituteTypes(tree: Tree, from: List[Symbol], to: List[Type]): Tree = tree.substituteTypes(from, to)
+    def substituteThis(tree: Tree, clazz: Symbol, to: Tree): Tree = tree.substituteThis(clazz, to)
+    def attachments(tree: Tree): Attachments { type Pos = Position } = tree.attachments
+    def updateAttachment[T: ClassTag](tree: Tree, attachment: T): tree.type = tree.updateAttachment(attachment)
+    def removeAttachment[T: ClassTag](tree: Tree): tree.type = tree.removeAttachment[T]
+    def setPos(tree: Tree, newpos: Position): tree.type = tree.setPos(newpos)
+    def setType(tree: Tree, tp: Type): tree.type = tree.setType(tp)
+    def defineType(tree: Tree, tp: Type): tree.type = tree.defineType(tp)
+    def setSymbol(tree: Tree, sym: Symbol): tree.type = tree.setSymbol(sym)
+    def setOriginal(tt: TypeTree, tree: Tree): TypeTree = tt.setOriginal(tree)
+
+    def captureVariable(vble: Symbol): Unit = self.captureVariable(vble)
+    def referenceCapturedVariable(vble: Symbol): Tree = self.referenceCapturedVariable(vble)
+    def capturedVariableType(vble: Symbol): Type = self.capturedVariableType(vble)
+
+    def classDef(sym: Symbol, impl: Template): ClassDef = self.ClassDef(sym, impl)
+    def moduleDef(sym: Symbol, impl: Template): ModuleDef = self.ModuleDef(sym, impl)
+    def valDef(sym: Symbol, rhs: Tree): ValDef = self.ValDef(sym, rhs)
+    def valDef(sym: Symbol): ValDef = self.ValDef(sym)
+    def defDef(sym: Symbol, mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree): DefDef = self.DefDef(sym, mods, vparamss, rhs)
+    def defDef(sym: Symbol, vparamss: List[List[ValDef]], rhs: Tree): DefDef = self.DefDef(sym, vparamss, rhs)
+    def defDef(sym: Symbol, mods: Modifiers, rhs: Tree): DefDef = self.DefDef(sym, mods, rhs)
+    def defDef(sym: Symbol, rhs: Tree): DefDef = self.DefDef(sym, rhs)
+    def defDef(sym: Symbol, rhs: List[List[Symbol]] => Tree): DefDef = self.DefDef(sym, rhs)
+    def typeDef(sym: Symbol, rhs: Tree): TypeDef = self.TypeDef(sym, rhs)
+    def typeDef(sym: Symbol): TypeDef = self.TypeDef(sym)
+    def labelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef = self.LabelDef(sym, params, rhs)
+
+    lazy val gen = self.treeBuild
+
+    def isFreeTerm(symbol: Symbol): Boolean = symbol.isFreeTerm
+    def asFreeTerm(symbol: Symbol): FreeTermSymbol = symbol.asFreeTerm
+    def isFreeType(symbol: Symbol): Boolean = symbol.isFreeType
+    def asFreeType(symbol: Symbol): FreeTypeSymbol = symbol.asFreeType
+    def newTermSymbol(symbol: Symbol, name: TermName, pos: Position = NoPosition, flags: FlagSet = NoFlags): TermSymbol = symbol.newTermSymbol(name, pos, flags)
+    def newModuleAndClassSymbol(symbol: Symbol, name: Name, pos: Position = NoPosition, flags: FlagSet = NoFlags): (ModuleSymbol, ClassSymbol) = symbol.newModuleAndClassSymbol(name, pos, flags)
+    def newMethodSymbol(symbol: Symbol, name: TermName, pos: Position = NoPosition, flags: FlagSet = NoFlags): MethodSymbol = symbol.newMethodSymbol(name, pos, flags)
+    def newTypeSymbol(symbol: Symbol, name: TypeName, pos: Position = NoPosition, flags: FlagSet = NoFlags): TypeSymbol = symbol.newTypeSymbol(name, pos, flags)
+    def newClassSymbol(symbol: Symbol, name: TypeName, pos: Position = NoPosition, flags: FlagSet = NoFlags): ClassSymbol = symbol.newClassSymbol(name, pos, flags)
+    def newFreeTerm(name: String, value: => Any, flags: FlagSet = NoFlags, origin: String = null): FreeTermSymbol = reificationSupport.newFreeTerm(name, value, flags, origin)
+    def newFreeType(name: String, flags: FlagSet = NoFlags, origin: String = null): FreeTypeSymbol = reificationSupport.newFreeType(name, flags, origin)
+    def isErroneous(symbol: Symbol): Boolean = symbol.isErroneous
+    def isSkolem(symbol: Symbol): Boolean = symbol.isSkolem
+    def deSkolemize(symbol: Symbol): Symbol = symbol.deSkolemize
+    def attachments(symbol: Symbol): Attachments { type Pos = Position } = symbol.attachments
+    def updateAttachment[T: ClassTag](symbol: Symbol, attachment: T): symbol.type = symbol.updateAttachment(attachment)
+    def removeAttachment[T: ClassTag](symbol: Symbol): symbol.type = symbol.removeAttachment[T]
+    def pos(symbol: Symbol): Position = symbol.pos
+    def setTypeSignature(symbol: Symbol, tpe: Type): symbol.type = symbol.setTypeSignature(tpe)
+    def setAnnotations(symbol: Symbol, annots: Annotation*): symbol.type = symbol.setAnnotations(annots: _*)
+    def setName(symbol: Symbol, name: Name): symbol.type = symbol.setName(name)
+    def setPrivateWithin(symbol: Symbol, sym: Symbol): symbol.type = symbol.setPrivateWithin(sym)
+
+    def thisType(sym: Symbol): Type = self.ThisType(sym)
+    def singleType(pre: Type, sym: Symbol): Type = self.SingleType(pre, sym)
+    def superType(thistpe: Type, supertpe: Type): Type = self.SuperType(thistpe, supertpe)
+    def constantType(value: Constant): ConstantType = self.ConstantType(value)
+    def typeRef(pre: Type, sym: Symbol, args: List[Type]): Type = self.TypeRef(pre, sym, args)
+    def refinedType(parents: List[Type], decls: Scope): RefinedType = self.RefinedType(parents, decls)
+    def refinedType(parents: List[Type], owner: Symbol): Type = self.refinedType(parents, owner)
+    def refinedType(parents: List[Type], owner: Symbol, decls: Scope): Type = self.RefinedType(parents, decls, owner)
+    def refinedType(parents: List[Type], owner: Symbol, decls: Scope, pos: Position): Type = self.refinedType(parents, owner, decls, pos)
+    def intersectionType(tps: List[Type]): Type = self.intersectionType(tps)
+    def intersectionType(tps: List[Type], owner: Symbol): Type = self.intersectionType(tps, owner)
+    def classInfoType(parents: List[Type], decls: Scope, typeSymbol: Symbol): ClassInfoType = self.ClassInfoType(parents, decls, typeSymbol)
+    def methodType(params: List[Symbol], resultType: Type): MethodType = self.MethodType(params, resultType)
+    def nullaryMethodType(resultType: Type): NullaryMethodType = self.NullaryMethodType(resultType)
+    def polyType(typeParams: List[Symbol], resultType: Type): PolyType = self.PolyType(typeParams, resultType)
+    def existentialType(quantified: List[Symbol], underlying: Type): ExistentialType = self.ExistentialType(quantified, underlying)
+    def existentialAbstraction(tparams: List[Symbol], tpe0: Type): Type = self.existentialAbstraction(tparams, tpe0)
+    def annotatedType(annotations: List[Annotation], underlying: Type): AnnotatedType = self.AnnotatedType(annotations, underlying)
+    def typeBounds(lo: Type, hi: Type): TypeBounds = self.TypeBounds(lo, hi)
+    def boundedWildcardType(bounds: TypeBounds): BoundedWildcardType = self.BoundedWildcardType(bounds)
+  }
+
+  lazy val treeBuild = new self.TreeGen {
+    def mkAttributedQualifier(tpe: Type): Tree = self.gen.mkAttributedQualifier(tpe)
+    def mkAttributedQualifier(tpe: Type, termSym: Symbol): Tree = self.gen.mkAttributedQualifier(tpe, termSym)
+    def mkAttributedRef(pre: Type, sym: Symbol): RefTree = self.gen.mkAttributedRef(pre, sym)
+    def mkAttributedRef(sym: Symbol): RefTree = self.gen.mkAttributedRef(sym)
+    def mkUnattributedRef(sym: Symbol): RefTree = self.gen.mkUnattributedRef(sym)
+    def mkUnattributedRef(fullName: Name): RefTree = self.gen.mkUnattributedRef(fullName)
+    def mkAttributedThis(sym: Symbol): This = self.gen.mkAttributedThis(sym)
+    def mkAttributedIdent(sym: Symbol): RefTree = self.gen.mkAttributedIdent(sym)
+    def mkAttributedSelect(qual: Tree, sym: Symbol): RefTree = self.gen.mkAttributedSelect(qual, sym)
+    def mkMethodCall(receiver: Symbol, methodName: Name, targs: List[Type], args: List[Tree]): Tree = self.gen.mkMethodCall(receiver, methodName, targs, args)
+    def mkMethodCall(method: Symbol, targs: List[Type], args: List[Tree]): Tree = self.gen.mkMethodCall(method, targs, args)
+    def mkMethodCall(method: Symbol, args: List[Tree]): Tree = self.gen.mkMethodCall(method, args)
+    def mkMethodCall(target: Tree, args: List[Tree]): Tree = self.gen.mkMethodCall(target, args)
+    def mkMethodCall(receiver: Symbol, methodName: Name, args: List[Tree]): Tree = self.gen.mkMethodCall(receiver, methodName, args)
+    def mkMethodCall(receiver: Tree, method: Symbol, targs: List[Type], args: List[Tree]): Tree = self.gen.mkMethodCall(receiver, method, targs, args)
+    def mkMethodCall(target: Tree, targs: List[Type], args: List[Tree]): Tree = self.gen.mkMethodCall(target, targs, args)
+    def mkNullaryCall(method: Symbol, targs: List[Type]): Tree = self.gen.mkNullaryCall(method, targs)
+    def mkRuntimeUniverseRef: Tree = self.gen.mkRuntimeUniverseRef
+  }
+}
\ No newline at end of file
diff --git a/src/reflect/scala/reflect/internal/BuildUtils.scala b/src/reflect/scala/reflect/internal/ReificationSupport.scala
index c5581601de..00ed9fb963 100644
--- a/src/reflect/scala/reflect/internal/BuildUtils.scala
+++ b/src/reflect/scala/reflect/internal/ReificationSupport.scala
@@ -5,10 +5,11 @@ package internal
 import Flags._
 import util._
 
-trait BuildUtils { self: SymbolTable =>
+trait ReificationSupport { self: SymbolTable =>
   import definitions.{TupleClass, FunctionClass, ScalaPackage, UnitClass}
+  import internal._
 
-  class BuildImpl extends BuildApi {
+  class ReificationSupportImpl extends ReificationSupportApi {
     def selectType(owner: Symbol, name: String): TypeSymbol =
       select(owner, newTypeName(name)).asType
 
@@ -41,6 +42,9 @@ trait BuildUtils { self: SymbolTable =>
     def newNestedSymbol(owner: Symbol, name: Name, pos: Position, flags: Long, isClass: Boolean): Symbol =
       owner.newNestedSymbol(name, pos, flags, isClass).markFlagsCompleted(mask = AllFlags)
 
+    def newScopeWith(elems: Symbol*): Scope =
+      self.newScopeWith(elems: _*)
+
     def setAnnotations[S <: Symbol](sym: S, annots: List[AnnotationInfo]): S =
       sym.setAnnotations(annots)
 
@@ -55,6 +59,34 @@ trait BuildUtils { self: SymbolTable =>
 
     def TypeTree(tp: Type): TypeTree = self.TypeTree(tp)
 
+    def ThisType(sym: Symbol): Type = self.ThisType(sym)
+
+    def SingleType(pre: Type, sym: Symbol): Type = self.SingleType(pre, sym)
+
+    def SuperType(thistpe: Type, supertpe: Type): Type = self.SuperType(thistpe, supertpe)
+
+    def ConstantType(value: Constant): ConstantType = self.ConstantType(value)
+
+    def TypeRef(pre: Type, sym: Symbol, args: List[Type]): Type = self.TypeRef(pre, sym, args)
+
+    def RefinedType(parents: List[Type], decls: Scope, typeSymbol: Symbol): RefinedType = self.RefinedType(parents, decls, typeSymbol)
+
+    def ClassInfoType(parents: List[Type], decls: Scope, typeSymbol: Symbol): ClassInfoType = self.ClassInfoType(parents, decls, typeSymbol)
+
+    def MethodType(params: List[Symbol], resultType: Type): MethodType = self.MethodType(params, resultType)
+
+    def NullaryMethodType(resultType: Type): NullaryMethodType = self.NullaryMethodType(resultType)
+
+    def PolyType(typeParams: List[Symbol], resultType: Type): PolyType = self.PolyType(typeParams, resultType)
+
+    def ExistentialType(quantified: List[Symbol], underlying: Type): ExistentialType = self.ExistentialType(quantified, underlying)
+
+    def AnnotatedType(annotations: List[Annotation], underlying: Type): AnnotatedType = self.AnnotatedType(annotations, underlying)
+
+    def TypeBounds(lo: Type, hi: Type): TypeBounds = self.TypeBounds(lo, hi)
+
+    def BoundedWildcardType(bounds: TypeBounds): BoundedWildcardType = self.BoundedWildcardType(bounds)
+
     def thisPrefix(sym: Symbol): Type = sym.thisPrefix
 
     def setType[T <: Tree](tree: T, tpe: Type): T = { tree.setType(tpe); tree }
@@ -911,5 +943,5 @@ trait BuildUtils { self: SymbolTable =>
     }
   }
 
-  val build: BuildImpl = new BuildImpl
+  val build = new ReificationSupportImpl
 }
diff --git a/src/reflect/scala/reflect/internal/StdAttachments.scala b/src/reflect/scala/reflect/internal/StdAttachments.scala
index 139a79ffe1..614e71b597 100644
--- a/src/reflect/scala/reflect/internal/StdAttachments.scala
+++ b/src/reflect/scala/reflect/internal/StdAttachments.scala
@@ -22,6 +22,16 @@ trait StdAttachments {
     def setPos(newpos: Position): this.type = { pos = newpos; this }
   }
 
+  /** Attachment that knows how to import itself into another universe. */
+  trait ImportableAttachment {
+    def importAttachment(importer: Importer): this.type
+  }
+
+  /** Attachment that doesn't contain any reflection artificats and can be imported as-is. */
+  trait PlainAttachment extends ImportableAttachment {
+    def importAttachment(importer: Importer): this.type = this
+  }
+
   /** Stores the trees that give rise to a refined type to be used in reification.
    *  Unfortunately typed `CompoundTypeTree` is lacking essential info, and the reifier cannot use `CompoundTypeTree.tpe`.
    *  Therefore we need this hack (see `Reshape.toPreTyperTypeTree` for a detailed explanation).
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index 01df1d6003..192735805d 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -321,7 +321,7 @@ trait StdNames {
     val FAKE_LOCAL_THIS: NameType          = "this$"
     val LAZY_LOCAL: NameType               = "$lzy"
     val LAZY_SLOW_SUFFIX: NameType         = "$lzycompute"
-    val UNIVERSE_BUILD_PREFIX: NameType    = "$u.build."
+    val UNIVERSE_BUILD_PREFIX: NameType    = "$u.internal.reificationSupport."
     val UNIVERSE_PREFIX: NameType          = "$u."
     val UNIVERSE_SHORT: NameType           = "$u"
     val MIRROR_PREFIX: NameType            = "$m."
@@ -577,9 +577,11 @@ trait StdNames {
     val AnyVal: NameType               = "AnyVal"
     val Apply: NameType                = "Apply"
     val ArrayAnnotArg: NameType        = "ArrayAnnotArg"
+    val ClassInfoType: NameType        = "ClassInfoType"
     val ConstantType: NameType         = "ConstantType"
     val EmptyPackage: NameType         = "EmptyPackage"
     val EmptyPackageClass: NameType    = "EmptyPackageClass"
+    val ExistentialType: NameType      = "ExistentialType"
     val Flag : NameType                = "Flag"
     val FlagsRepr: NameType            = "FlagsRepr"
     val Ident: NameType                = "Ident"
@@ -587,6 +589,7 @@ trait StdNames {
     val Import: NameType               = "Import"
     val Literal: NameType              = "Literal"
     val LiteralAnnotArg: NameType      = "LiteralAnnotArg"
+    val MethodType: NameType           = "MethodType"
     val Modifiers: NameType            = "Modifiers"
     val NestedAnnotArg: NameType       = "NestedAnnotArg"
     val New: NameType                  = "New"
@@ -595,11 +598,16 @@ trait StdNames {
     val NoMods: NameType               = "NoMods"
     val Nothing: NameType              = "Nothing"
     val Null: NameType                 = "Null"
+    val NullaryMethodType: NameType    = "NullaryMethodType"
     val Object: NameType               = "Object"
+    val PolyType: NameType             = "PolyType"
+    val RefinedType: NameType          = "RefinedType"
     val RootPackage: NameType          = "RootPackage"
     val RootClass: NameType            = "RootClass"
     val Select: NameType               = "Select"
     val SelectFromTypeTree: NameType   = "SelectFromTypeTree"
+    val SingleType: NameType           = "SingleType"
+    val SuperType: NameType            = "SuperType"
     val SyntacticApplied: NameType     = "SyntacticApplied"
     val SyntacticAssign: NameType      = "SyntacticAssign"
     val SyntacticBlock: NameType       = "SyntacticBlock"
@@ -630,6 +638,7 @@ trait StdNames {
     val ThisType: NameType             = "ThisType"
     val Tuple2: NameType               = "Tuple2"
     val TYPE_ : NameType               = "TYPE"
+    val TypeBounds: NameType           = "TypeBounds"
     val TypeRef: NameType              = "TypeRef"
     val TypeTree: NameType             = "TypeTree"
     val UNIT : NameType                = "UNIT"
@@ -653,7 +662,6 @@ trait StdNames {
     val asInstanceOf_ : NameType       = "asInstanceOf"
     val asInstanceOf_Ob : NameType     = "$asInstanceOf"
     val box: NameType                  = "box"
-    val build : NameType               = "build"
     val bytes: NameType                = "bytes"
     val c: NameType                    = "c"
     val canEqual_ : NameType           = "canEqual"
@@ -695,6 +703,7 @@ trait StdNames {
     val immutable: NameType            = "immutable"
     val implicitly: NameType           = "implicitly"
     val in: NameType                   = "in"
+    val internal: NameType             = "internal"
     val inlinedEquals: NameType        = "inlinedEquals"
     val isArray: NameType              = "isArray"
     val isDefinedAt: NameType          = "isDefinedAt"
@@ -735,6 +744,7 @@ trait StdNames {
     val productPrefix: NameType        = "productPrefix"
     val readResolve: NameType          = "readResolve"
     val reify : NameType               = "reify"
+    val reificationSupport : NameType  = "reificationSupport"
     val rootMirror : NameType          = "rootMirror"
     val runtime: NameType              = "runtime"
     val runtimeClass: NameType         = "runtimeClass"
diff --git a/src/reflect/scala/reflect/internal/SymbolTable.scala b/src/reflect/scala/reflect/internal/SymbolTable.scala
index 802bd18a4e..e50c65c9ca 100644
--- a/src/reflect/scala/reflect/internal/SymbolTable.scala
+++ b/src/reflect/scala/reflect/internal/SymbolTable.scala
@@ -11,6 +11,7 @@ import scala.annotation.elidable
 import scala.collection.{ mutable, immutable }
 import util._
 import java.util.concurrent.TimeUnit
+import scala.reflect.internal.{TreeGen => InternalTreeGen}
 
 abstract class SymbolTable extends macros.Universe
                               with Collections
@@ -40,14 +41,14 @@ abstract class SymbolTable extends macros.Universe
                               with CapturedVariables
                               with StdAttachments
                               with StdCreators
-                              with BuildUtils
+                              with ReificationSupport
                               with PrivateWithin
                               with pickling.Translations
                               with FreshNames
+                              with Internals
 {
 
-  val gen = new TreeGen { val global: SymbolTable.this.type = SymbolTable.this }
-  lazy val treeBuild = gen
+  val gen = new InternalTreeGen { val global: SymbolTable.this.type = SymbolTable.this }
 
   def log(msg: => AnyRef): Unit
   def warning(msg: String): Unit     = Console.err.println(msg)
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 63a69e2797..c4fc450a78 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -79,9 +79,14 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
   def symbolOf[T: WeakTypeTag]: TypeSymbol = weakTypeOf[T].typeSymbolDirect.asType
 
-  abstract class SymbolContextApiImpl extends SymbolContextApi {
+  abstract class SymbolContextApiImpl extends SymbolApi {
     this: Symbol =>
 
+    def isFreeTerm: Boolean = false
+    def asFreeTerm: FreeTermSymbol = throw new ScalaReflectionException(s"$this is not a free term")
+    def isFreeType: Boolean = false
+    def asFreeType: FreeTypeSymbol = throw new ScalaReflectionException(s"$this is not a free type")
+
     def isExistential: Boolean = this.isExistentiallyBound
     def isParamWithDefault: Boolean = this.hasDefault
     // `isByNameParam` is only true for a call-by-name parameter of a *method*,
@@ -115,6 +120,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def baseClasses                       = info.baseClasses
     def module                            = sourceModule
     def thisPrefix: Type                  = thisType
+    def superPrefix(supertpe: Type): Type = SuperType(thisType, supertpe)
 
     // automatic full initialization on access to info from reflection API is a double-edged sword
     // on the one hand, it's convenient so that the users don't have to deal with initialization themselves before printing out stuff
@@ -3366,11 +3372,16 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def origin: String
   }
   class FreeTermSymbol(name0: TermName, value0: => Any, val origin: String) extends TermSymbol(NoSymbol, NoPosition, name0) with FreeSymbol with FreeTermSymbolApi {
+    final override def isFreeTerm = true
+    final override def asFreeTerm = this
     def value = value0
   }
   implicit val FreeTermSymbolTag = ClassTag[FreeTermSymbol](classOf[FreeTermSymbol])
 
-  class FreeTypeSymbol(name0: TypeName, val origin: String) extends TypeSkolem(NoSymbol, NoPosition, name0, NoSymbol) with FreeSymbol with FreeTypeSymbolApi
+  class FreeTypeSymbol(name0: TypeName, val origin: String) extends TypeSkolem(NoSymbol, NoPosition, name0, NoSymbol) with FreeSymbol with FreeTypeSymbolApi {
+    final override def isFreeType = true
+    final override def asFreeType = this
+  }
   implicit val FreeTypeSymbolTag = ClassTag[FreeTypeSymbol](classOf[FreeTypeSymbol])
 
   /** An object representing a missing symbol */
diff --git a/src/reflect/scala/reflect/internal/TreeGen.scala b/src/reflect/scala/reflect/internal/TreeGen.scala
index 9de5c1a7ea..e8e57f9eb3 100644
--- a/src/reflect/scala/reflect/internal/TreeGen.scala
+++ b/src/reflect/scala/reflect/internal/TreeGen.scala
@@ -6,7 +6,7 @@ import Flags._
 import util._
 import scala.collection.mutable.ListBuffer
 
-abstract class TreeGen extends macros.TreeBuilder {
+abstract class TreeGen {
   val global: SymbolTable
 
   import global._
diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index 3b84ef6aeb..42952e5d80 100644
--- a/src/reflect/scala/reflect/internal/Trees.scala
+++ b/src/reflect/scala/reflect/internal/Trees.scala
@@ -99,7 +99,7 @@ trait Trees extends api.Trees {
       (duplicator transform this).asInstanceOf[this.type]
   }
 
-  abstract class TreeContextApiImpl extends TreeContextApi { this: Tree =>
+  abstract class TreeContextApiImpl extends TreeApi { this: Tree =>
 
     override def orElse(alt: => Tree) = if (!isEmpty) this else alt
 
@@ -158,8 +158,8 @@ trait Trees extends api.Trees {
       productIterator.toList flatMap subtrees
     }
 
-    override def freeTerms: List[FreeTermSymbol] = freeSyms[FreeTermSymbol](_.isFreeTerm, _.termSymbol)
-    override def freeTypes: List[FreeTypeSymbol] = freeSyms[FreeTypeSymbol](_.isFreeType, _.typeSymbol)
+    def freeTerms: List[FreeTermSymbol] = freeSyms[FreeTermSymbol](_.isFreeTerm, _.termSymbol)
+    def freeTypes: List[FreeTypeSymbol] = freeSyms[FreeTypeSymbol](_.isFreeType, _.typeSymbol)
 
     private def freeSyms[S <: Symbol](isFree: Symbol => Boolean, symOfType: Type => Symbol): List[S] = {
       val s = mutable.LinkedHashSet[S]()
@@ -175,13 +175,13 @@ trait Trees extends api.Trees {
       s.toList
     }
 
-    override def substituteSymbols(from: List[Symbol], to: List[Symbol]): Tree =
+    def substituteSymbols(from: List[Symbol], to: List[Symbol]): Tree =
       new TreeSymSubstituter(from, to)(this)
 
-    override def substituteTypes(from: List[Symbol], to: List[Type]): Tree =
+    def substituteTypes(from: List[Symbol], to: List[Type]): Tree =
       new TreeTypeSubstituter(from, to)(this)
 
-    override def substituteThis(clazz: Symbol, to: Tree): Tree =
+    def substituteThis(clazz: Symbol, to: Tree): Tree =
       new ThisSubstituter(clazz, to) transform this
 
     def hasExistingSymbol = (symbol ne null) && (symbol ne NoSymbol)
@@ -235,7 +235,7 @@ trait Trees extends api.Trees {
 
   trait TypTree extends Tree with TypTreeApi
 
-  abstract class SymTree extends Tree with SymTreeContextApi {
+  abstract class SymTree extends Tree with SymTreeApi {
     override def hasSymbolField = true
     override var symbol: Symbol = NoSymbol
   }
@@ -488,7 +488,7 @@ trait Trees extends api.Trees {
   }
   object Select extends SelectExtractor
 
-  case class Ident(name: Name) extends RefTree with IdentContextApi {
+  case class Ident(name: Name) extends RefTree with IdentApi {
     def qualifier: Tree = EmptyTree
     def isBackquoted = this.hasAttachment[BackquotedIdentifierAttachment.type]
   }
@@ -545,7 +545,7 @@ trait Trees extends api.Trees {
        extends TypTree with ExistentialTypeTreeApi
   object ExistentialTypeTree extends ExistentialTypeTreeExtractor
 
-  case class TypeTree() extends TypTree with TypeTreeContextApi {
+  case class TypeTree() extends TypTree with TypeTreeApi {
     private var orig: Tree = null
     /** Was this type tree originally empty? That is, does it now contain
       * an inferred type that must be forgotten in `resetAttrs` to
@@ -1849,8 +1849,8 @@ trait Trees extends api.Trees {
   implicit val NameTreeTag            = ClassTag[NameTree](classOf[NameTree])
   implicit val NewTag                 = ClassTag[New](classOf[New])
   implicit val PackageDefTag          = ClassTag[PackageDef](classOf[PackageDef])
-  implicit val RefTreeTag             = ClassTag[RefTree](classOf[RefTree])
   implicit val ReferenceToBoxedTag    = ClassTag[ReferenceToBoxed](classOf[ReferenceToBoxed])
+  implicit val RefTreeTag             = ClassTag[RefTree](classOf[RefTree])
   implicit val ReturnTag              = ClassTag[Return](classOf[Return])
   implicit val SelectFromTypeTreeTag  = ClassTag[SelectFromTypeTree](classOf[SelectFromTypeTree])
   implicit val SelectTag              = ClassTag[Select](classOf[Select])
diff --git a/src/reflect/scala/reflect/macros/Reifiers.scala b/src/reflect/scala/reflect/macros/Reifiers.scala
index ff1f7a3b28..e35a5c8622 100644
--- a/src/reflect/scala/reflect/macros/Reifiers.scala
+++ b/src/reflect/scala/reflect/macros/Reifiers.scala
@@ -15,7 +15,7 @@ trait Reifiers {
    *  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 `universe.treeBuild.mkRuntimeUniverseRef`.
+   *  Possible values for `universe` include `universe.internal.gen.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.
diff --git a/src/reflect/scala/reflect/macros/TreeBuilder.scala b/src/reflect/scala/reflect/macros/TreeBuilder.scala
deleted file mode 100644
index 7f57274347..0000000000
--- a/src/reflect/scala/reflect/macros/TreeBuilder.scala
+++ /dev/null
@@ -1,97 +0,0 @@
-package scala
-package reflect
-package macros
-
-/**
- * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
- *
- *  A helper available in [[scala.reflect.macros.Universe]] that defines shorthands for the
- *  most common tree-creating functions.
- */
-@deprecated("Use quasiquotes instead", "2.11.0")
-abstract class TreeBuilder {
-  val global: Universe
-
-  import global._
-
-  /** Builds a reference to value whose type is given stable prefix.
-   *  The type must be suitable for this.  For example, it
-   *  must not be a TypeRef pointing to an abstract type variable.
-   */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkAttributedQualifier(tpe: Type): Tree
-
-  /** Builds a reference to value whose type is given stable prefix.
-   *  If the type is unsuitable, e.g. it is a TypeRef for an
-   *  abstract type variable, then an Ident will be made using
-   *  termSym as the Ident's symbol.  In that case, termSym must
-   *  not be NoSymbol.
-   */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkAttributedQualifier(tpe: Type, termSym: Symbol): Tree
-
-  /** Builds a typed reference to given symbol with given stable prefix. */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkAttributedRef(pre: Type, sym: Symbol): RefTree
-
-  /** Builds a typed reference to given symbol. */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkAttributedRef(sym: Symbol): RefTree
-
-  /** Builds an untyped reference to given symbol. Requires the symbol to be static. */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkUnattributedRef(sym: Symbol): RefTree
-
-  /** Builds an untyped reference to symbol with given name. Requires the symbol to be static. */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkUnattributedRef(fullName: Name): RefTree
-
-  /** Builds a typed This reference to given symbol. */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkAttributedThis(sym: Symbol): This
-
-  /** Builds a typed Ident with an underlying symbol. */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkAttributedIdent(sym: Symbol): RefTree
-
-  /** Builds a typed Select with an underlying symbol. */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkAttributedSelect(qual: Tree, sym: Symbol): RefTree
-
-  /** A creator for method calls, e.g. fn[T1, T2, ...](v1, v2, ...)
-   *  There are a number of variations.
-   *
-   *  @param    receiver    symbol of the method receiver
-   *  @param    methodName  name of the method to call
-   *  @param    targs       type arguments (if Nil, no TypeApply node will be generated)
-   *  @param    args        value arguments
-   *  @return               the newly created trees.
-   */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkMethodCall(receiver: Symbol, methodName: Name, targs: List[Type], args: List[Tree]): Tree
-
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkMethodCall(method: Symbol, targs: List[Type], args: List[Tree]): Tree
-
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkMethodCall(method: Symbol, args: List[Tree]): Tree
-
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkMethodCall(target: Tree, args: List[Tree]): Tree
-
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkMethodCall(receiver: Symbol, methodName: Name, args: List[Tree]): Tree
-
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkMethodCall(receiver: Tree, method: Symbol, targs: List[Type], args: List[Tree]): Tree
-
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkMethodCall(target: Tree, targs: List[Type], args: List[Tree]): Tree
-
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkNullaryCall(method: Symbol, targs: List[Type]): Tree
-
-  /** A tree that refers to the runtime reflexive universe, `scala.reflect.runtime.universe`. */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  def mkRuntimeUniverseRef: Tree
-}
diff --git a/src/reflect/scala/reflect/macros/Universe.scala b/src/reflect/scala/reflect/macros/Universe.scala
index bc5c8b2840..17eb17cee3 100644
--- a/src/reflect/scala/reflect/macros/Universe.scala
+++ b/src/reflect/scala/reflect/macros/Universe.scala
@@ -2,6 +2,8 @@ package scala
 package reflect
 package macros
 
+import scala.language.implicitConversions
+
 /**
  * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
  *
@@ -17,109 +19,63 @@ package macros
  */
 abstract class Universe extends scala.reflect.api.Universe {
 
-  /** A factory that encapsulates common tree-building functions.
-   *  @group Macros
-   */
-  @deprecated("Use quasiquotes instead", "2.11.0")
-  val treeBuild: TreeBuilder { val global: Universe.this.type }
+  /** @inheritdoc */
+  override type Internal <: MacroInternalApi
 
-  /** The API of reflection artifacts that support [[scala.reflect.macros.Attachments]].
-   *  These artifacts are trees and symbols.
-   *  @group Macros
-   */
-  trait AttachableApi {
-    /** The attachment of the reflection artifact. */
-    def attachments: Attachments { type Pos = Position }
+  /** @inheritdoc */
+  trait MacroInternalApi extends InternalApi {
+
+    /** Advanced tree factories */
+    val gen: TreeGen
+
+    /** The attachment of the symbol. */
+    def attachments(symbol: Symbol): Attachments { type Pos = Position }
 
     /** Updates the attachment with the payload slot of T added/updated with the provided value.
      *  Replaces an existing payload of the same type, if exists.
-     *  Returns the reflection artifact itself.
+     *  Returns the symbol itself.
      */
-    def updateAttachment[T: ClassTag](attachment: T): AttachableApi.this.type
+    def updateAttachment[T: ClassTag](symbol: Symbol, attachment: T): symbol.type
 
     /** Update the attachment with the payload of the given class type `T` removed.
-     *  Returns the reflection artifact itself.
-     */
-    def removeAttachment[T: ClassTag]: AttachableApi.this.type
-  }
-
-  // Symbol extensions ---------------------------------------------------------------
-
-  /**  The `Symbol` API is extended for macros: See [[SymbolContextApi]] for details.
-   *
-   *  @group Macros
-   */
-  override type Symbol >: Null <: SymbolContextApi
-
-  /** The extended API of symbols that's supported in macro context universes
-   *  @group API
-   */
-  trait SymbolContextApi extends SymbolApi with AttachableApi { self: Symbol =>
-
-    /** If this symbol is a skolem, its corresponding type parameter, otherwise the symbol itself.
-     *
-     *  [[https://groups.google.com/forum/#!msg/scala-internals/0j8laVNTQsI/kRXMF_c8bGsJ To quote Martin Odersky]],
-     *  skolems are synthetic type "constants" that are copies of existentially bound or universally
-     *  bound type variables. E.g. if one is inside the right-hand side of a method:
-     *
-     *  {{{
-     *  def foo[T](x: T) = ... foo[List[T]]....
-     *  }}}
-     *
-     *  the skolem named `T` refers to the unknown type instance of `T` when `foo` is called. It needs to be different
-     *  from the type parameter because in a recursive call as in the `foo[List[T]]` above the type parameter gets
-     *  substituted with `List[T]`, but the ''type skolem'' stays what it is.
-     *
-     *  The other form of skolem is an ''existential skolem''. Say one has a function
-     *
-     *  {{{
-     *  def bar(xs: List[T] forSome { type T }) = xs.head
-     *  }}}
-     *
-     *  then each occurrence of `xs` on the right will have type `List[T']` where `T'` is a fresh copy of `T`.
+     *  Returns the symbol itself.
      */
-    def deSkolemize: Symbol
+    def removeAttachment[T: ClassTag](symbol: Symbol): symbol.type
 
     /** The position of this symbol. */
-    def pos: Position
+    def pos(symbol: Symbol): Position
 
     /** Sets the `typeSignature` of the symbol. */
-    def setTypeSignature(tpe: Type): Symbol
+    def setTypeSignature(symbol: Symbol, tpe: Type): symbol.type
 
     /** Sets the `annotations` of the symbol. */
-    def setAnnotations(annots: Annotation*): Symbol
+    def setAnnotations(symbol: Symbol, annots: Annotation*): symbol.type
 
     /** Sets the `name` of the symbol. */
-    def setName(name: Name): Symbol
+    def setName(symbol: Symbol, name: Name): symbol.type
 
     /** Sets the `privateWithin` of the symbol. */
-    def setPrivateWithin(sym: Symbol): Symbol
-  }
+    def setPrivateWithin(symbol: Symbol, sym: Symbol): symbol.type
 
-  // Tree extensions ---------------------------------------------------------------
+    /** The attachment of the tree. */
+    def attachments(tree: Tree): Attachments { type Pos = Position }
 
-  /**  The `Tree` API is extended for macros: See [[TreeContextApi]] for details.
-   *
-   *  @group Macros
-   */
-  override type Tree >: Null <: TreeContextApi
-
-  /** The extended API of trees that's supported in macro context universes
-   *  @group API
-   */
-  trait TreeContextApi extends TreeApi with AttachableApi { self: Tree =>
+    /** Updates the attachment with the payload slot of T added/updated with the provided value.
+     *  Replaces an existing payload of the same type, if exists.
+     *  Returns the tree itself.
+     */
+    def updateAttachment[T: ClassTag](tree: Tree, attachment: T): tree.type
 
-    /** Sets the `pos` of the tree. Returns `Unit`. */
-    def pos_=(pos: Position): Unit
+    /** Update the attachment with the payload of the given class type `T` removed.
+     *  Returns the tree itself.
+     */
+    def removeAttachment[T: ClassTag](tree: Tree): tree.type
 
     /** Sets the `pos` of the tree. Returns the tree itself. */
-    def setPos(newpos: Position): Tree
-
-    /** Sets the `tpe` of the tree. Returns `Unit`. */
-    @deprecated("Use setType", "2.11.0") def tpe_=(t: Type): Unit
+    def setPos(tree: Tree, newpos: Position): tree.type
 
     /** Sets the `tpe` of the tree. Returns the tree itself. */
-    def setType(tp: Type): Tree
+    def setType(tree: Tree, tp: Type): tree.type
 
     /** Like `setType`, but if this is a previously empty TypeTree that
      *  fact is remembered so that `untypecheck` will snap back.
@@ -139,63 +95,96 @@ abstract class Universe extends scala.reflect.api.Universe {
      *  and therefore should be abandoned if the current line of type
      *  inquiry doesn't work out.
      */
-    def defineType(tp: Type): Tree
-
-    /** Sets the `symbol` of the tree. Returns `Unit`. */
-    def symbol_=(sym: Symbol): Unit
+    def defineType(tree: Tree, tp: Type): tree.type
 
     /** Sets the `symbol` of the tree. Returns the tree itself. */
-    def setSymbol(sym: Symbol): Tree
-  }
+    def setSymbol(tree: Tree, sym: Symbol): tree.type
 
-  /** @inheritdoc */
-  override type SymTree >: Null <: Tree with SymTreeContextApi
+    /** Sets the `original` field of the type tree. */
+    def setOriginal(tt: TypeTree, original: Tree): TypeTree
 
-  /** The extended API of sym trees that's supported in macro context universes
-   *  @group API
-   */
-  trait SymTreeContextApi extends SymTreeApi { this: SymTree =>
-    /** Sets the `symbol` field of the sym tree. */
-    var symbol: Symbol
-  }
+    /** Mark a variable as captured; i.e. force boxing in a *Ref type.
+     *  @group Macros
+     */
+    def captureVariable(vble: Symbol): Unit
 
-  /** @inheritdoc */
-  override type TypeTree >: Null <: TypTree with TypeTreeContextApi
+    /** Mark given identifier as a reference to a captured variable itself
+     *  suppressing dereferencing with the `elem` field.
+     *  @group Macros
+     */
+    def referenceCapturedVariable(vble: Symbol): Tree
 
-  /** The extended API of sym trees that's supported in macro context universes
-   *  @group API
-   */
-  trait TypeTreeContextApi extends TypeTreeApi { this: TypeTree =>
-    /** Sets the `original` field of the type tree. */
-    def setOriginal(tree: Tree): this.type
+    /** Convert type of a captured variable to *Ref type.
+     *  @group Macros
+     */
+    def capturedVariableType(vble: Symbol): Type
   }
 
-  /** @inheritdoc */
-  override type Ident >: Null <: RefTree with IdentContextApi
+  /** @group Internal */
+  trait TreeGen {
+    /** Builds a reference to value whose type is given stable prefix.
+     *  The type must be suitable for this.  For example, it
+     *  must not be a TypeRef pointing to an abstract type variable.
+     */
+    def mkAttributedQualifier(tpe: Type): Tree
 
-  /** The extended API of idents that's supported in macro context universes
-   *  @group API
-   */
-  trait IdentContextApi extends IdentApi { this: Ident =>
-    /** Was this ident created from a backquoted identifier? */
-    def isBackquoted: Boolean
-  }
+    /** Builds a reference to value whose type is given stable prefix.
+     *  If the type is unsuitable, e.g. it is a TypeRef for an
+     *  abstract type variable, then an Ident will be made using
+     *  termSym as the Ident's symbol.  In that case, termSym must
+     *  not be NoSymbol.
+     */
+    def mkAttributedQualifier(tpe: Type, termSym: Symbol): Tree
 
-  /** Mark a variable as captured; i.e. force boxing in a *Ref type.
-   *  @group Macros
-   */
-  def captureVariable(vble: Symbol): Unit
+    /** Builds a typed reference to given symbol with given stable prefix. */
+    def mkAttributedRef(pre: Type, sym: Symbol): RefTree
 
-  /** Mark given identifier as a reference to a captured variable itself
-   *  suppressing dereferencing with the `elem` field.
-   *  @group Macros
-   */
-  def referenceCapturedVariable(vble: Symbol): Tree
+    /** Builds a typed reference to given symbol. */
+    def mkAttributedRef(sym: Symbol): RefTree
 
-  /** Convert type of a captured variable to *Ref type.
-   *  @group Macros
-   */
-  def capturedVariableType(vble: Symbol): Type
+    /** Builds an untyped reference to given symbol. Requires the symbol to be static. */
+    def mkUnattributedRef(sym: Symbol): RefTree
+
+    /** Builds an untyped reference to symbol with given name. Requires the symbol to be static. */
+    def mkUnattributedRef(fullName: Name): RefTree
+
+    /** Builds a typed This reference to given symbol. */
+    def mkAttributedThis(sym: Symbol): This
+
+    /** Builds a typed Ident with an underlying symbol. */
+    def mkAttributedIdent(sym: Symbol): RefTree
+
+    /** Builds a typed Select with an underlying symbol. */
+    def mkAttributedSelect(qual: Tree, sym: Symbol): RefTree
+
+    /** A creator for method calls, e.g. fn[T1, T2, ...](v1, v2, ...)
+     *  There are a number of variations.
+     *
+     *  @param    receiver    symbol of the method receiver
+     *  @param    methodName  name of the method to call
+     *  @param    targs       type arguments (if Nil, no TypeApply node will be generated)
+     *  @param    args        value arguments
+     *  @return               the newly created trees.
+     */
+    def mkMethodCall(receiver: Symbol, methodName: Name, targs: List[Type], args: List[Tree]): Tree
+
+    def mkMethodCall(method: Symbol, targs: List[Type], args: List[Tree]): Tree
+
+    def mkMethodCall(method: Symbol, args: List[Tree]): Tree
+
+    def mkMethodCall(target: Tree, args: List[Tree]): Tree
+
+    def mkMethodCall(receiver: Symbol, methodName: Name, args: List[Tree]): Tree
+
+    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
+  }
 
   /** The type of compilation runs.
    *  @see [[scala.reflect.macros.Enclosures]]
diff --git a/src/reflect/scala/reflect/runtime/JavaUniverse.scala b/src/reflect/scala/reflect/runtime/JavaUniverse.scala
index 85c56bc4bb..b5446694ed 100644
--- a/src/reflect/scala/reflect/runtime/JavaUniverse.scala
+++ b/src/reflect/scala/reflect/runtime/JavaUniverse.scala
@@ -2,18 +2,22 @@ package scala
 package reflect
 package runtime
 
+import scala.reflect.internal.{TreeInfo, SomePhase}
+import scala.reflect.internal.{SymbolTable => InternalSymbolTable}
+import scala.reflect.runtime.{SymbolTable => RuntimeSymbolTable}
+import scala.reflect.api.{TreeCreator, TypeCreator, Universe}
+
 /** An implementation of [[scala.reflect.api.Universe]] for runtime reflection using JVM classloaders.
  *
  *  Should not be instantiated directly, use [[scala.reflect.runtime.universe]] instead.
  *
  *  @contentDiagram hideNodes "*Api" "*Extractor"
  */
-class JavaUniverse extends internal.SymbolTable with JavaUniverseForce with ReflectSetup with runtime.SymbolTable { self =>
+class JavaUniverse extends InternalSymbolTable with JavaUniverseForce with ReflectSetup with RuntimeSymbolTable { self =>
 
   override def inform(msg: String): Unit = log(msg)
-  def picklerPhase = internal.SomePhase
-  def erasurePhase = internal.SomePhase
-
+  def picklerPhase = SomePhase
+  def erasurePhase = SomePhase
   lazy val settings = new Settings
   private val isLogging = sys.props contains "scala.debug.reflect"
 
@@ -26,10 +30,38 @@ class JavaUniverse extends internal.SymbolTable with JavaUniverseForce with Refl
 
   def currentFreshNameCreator = globalFreshNameCreator
 
+  override lazy val internal: Internal = new SymbolTableInternal {
+    override def typeTagToManifest[T: ClassTag](mirror0: Any, tag: Universe # TypeTag[T]): Manifest[T] = {
+      // SI-6239: make this conversion more precise
+      val mirror = mirror0.asInstanceOf[Mirror]
+      val runtimeClass = mirror.runtimeClass(tag.in(mirror).tpe)
+      Manifest.classType(runtimeClass).asInstanceOf[Manifest[T]]
+    }
+    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: scala.reflect.api.Mirror[U]): U # Type = {
+          mirror.universe match {
+            case ju: JavaUniverse =>
+              val jm = mirror.asInstanceOf[ju.Mirror]
+              val sym = jm.classSymbol(manifest.runtimeClass)
+              val tpe =
+                if (manifest.typeArguments.isEmpty) sym.toType
+                else {
+                  val tags = manifest.typeArguments map (targ => ju.internal.manifestToTypeTag(jm, targ))
+                  ju.appliedType(sym.toTypeConstructor, tags map (_.in(jm).tpe))
+                }
+              tpe.asInstanceOf[U # Type]
+            case u =>
+              u.internal.manifestToTypeTag(mirror.asInstanceOf[u.Mirror], manifest).in(mirror).tpe
+          }
+        }
+      })
+  }
+
   // can't put this in runtime.Trees since that's mixed with Global in ReflectGlobal, which has the definition from internal.Trees
   object treeInfo extends {
     val global: JavaUniverse.this.type = JavaUniverse.this
-  } with internal.TreeInfo
+  } with TreeInfo
 
   init()
 
diff --git a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
index 0fcf215580..be8a2865d3 100644
--- a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
+++ b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
@@ -26,11 +26,12 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     TypeTag.Null.tpe
 
     this.settings
+    this.internal
     this.treeInfo
     this.rootMirror
-    this.treeBuild
     this.traceSymbols
     this.perRunCaches
+    this.treeBuild
     this.FreshNameExtractor
     this.FixedMirrorTreeCreator
     this.FixedMirrorTypeCreator
@@ -279,6 +280,7 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     definitions.ReflectPackage
     definitions.ReflectApiPackage
     definitions.ReflectRuntimePackage
+    definitions.UniverseClass
     definitions.PartialManifestModule
     definitions.FullManifestClass
     definitions.FullManifestModule
diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala
index d261fc5be9..8bb5757bbb 100644
--- a/src/repl/scala/tools/nsc/interpreter/IMain.scala
+++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala
@@ -1031,7 +1031,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
   def lastWarnings = mostRecentWarnings
 
   private lazy val importToGlobal  = global mkImporter ru
-  private lazy val importToRuntime = ru mkImporter global
+  private lazy val importToRuntime = ru.internal createImporter global
   private lazy val javaMirror = ru.rootMirror match {
     case x: ru.JavaMirror => x
     case _                => null