Merge pull request #936 from scalamacros/ticket/5999

SI-5999 consistent behavior for c.reify and c.universe.reify

61 files changed, 471 insertions, 237 deletions

diff --git a/build.xml b/build.xml
index 8fa1b9cd76..160a699ca2 100644
--- a/build.xml
+++ b/build.xml
@@ -397,7 +397,7 @@ INITIALISATION
   </target>
 
   <target name="init" depends="init.jars, init.maven.jars, init.version.done, init.fail.bad.jdk, init.warn.jdk7">
-    <property name="scalac.args.always" value="" />
+    <property name="scalac.args.always" value="-Yreify-copypaste" />
   <!-- scalac.args.optimise is selectively overridden in certain antcall tasks. -->
     <property name="scalac.args.optimise" value=""/>
   <!-- scalac.args.quickonly are added to quick.* targets but not others (particularly, locker.)
diff --git a/lib/scala-compiler-src.jar.desired.sha1 b/lib/scala-compiler-src.jar.desired.sha1
index 48b3d3284e..6840b60528 100644
--- a/lib/scala-compiler-src.jar.desired.sha1
+++ b/lib/scala-compiler-src.jar.desired.sha1
@@ -1 +1 @@
-259fd9f0a50ed6003248a01a366a97a5549aa386 ?scala-compiler-src.jar
+6a03de33fb670e1b1a9930234adb6d1d6435323d ?scala-compiler-src.jar
diff --git a/lib/scala-compiler.jar.desired.sha1 b/lib/scala-compiler.jar.desired.sha1
index a8dbdb0a38..393820f481 100644
--- a/lib/scala-compiler.jar.desired.sha1
+++ b/lib/scala-compiler.jar.desired.sha1
@@ -1 +1 @@
-42f7367cc6ac59022d098e6091e5425390b9c925 ?scala-compiler.jar
+cf6aab754bcf77ab433e2b05d1f452e13f24cedc ?scala-compiler.jar
diff --git a/lib/scala-library-src.jar.desired.sha1 b/lib/scala-library-src.jar.desired.sha1
index 3379287733..cefff7eec9 100644
--- a/lib/scala-library-src.jar.desired.sha1
+++ b/lib/scala-library-src.jar.desired.sha1
@@ -1 +1 @@
-e31e38414fd19c10add3e65bf77c2fd7c6c26f7d ?scala-library-src.jar
+02dcd8656f99eabbad8d9dce06a33d4f6f8d7c38 ?scala-library-src.jar
diff --git a/lib/scala-library.jar.desired.sha1 b/lib/scala-library.jar.desired.sha1
index bef528ce26..f7f2321177 100644
--- a/lib/scala-library.jar.desired.sha1
+++ b/lib/scala-library.jar.desired.sha1
@@ -1 +1 @@
-2418c95bf7db34f87ebda4a5eaa918fe85047afb ?scala-library.jar
+6a035e798a94c6ca051e6a7663293cfee3d7136f ?scala-library.jar
diff --git a/lib/scala-reflect-src.jar.desired.sha1 b/lib/scala-reflect-src.jar.desired.sha1
index b3a5f03efe..fb09e9d585 100644
--- a/lib/scala-reflect-src.jar.desired.sha1
+++ b/lib/scala-reflect-src.jar.desired.sha1
@@ -1 +1 @@
-51c64d77ad4c4233a06cea7ea80b0fb77e9867c4 ?scala-reflect-src.jar
+ecb9dd737935812a6399a3426e9126908ef870b2 ?scala-reflect-src.jar
diff --git a/lib/scala-reflect.jar.desired.sha1 b/lib/scala-reflect.jar.desired.sha1
index 4d913d73ab..dc5b7abd0e 100644
--- a/lib/scala-reflect.jar.desired.sha1
+++ b/lib/scala-reflect.jar.desired.sha1
@@ -1 +1 @@
-5656bf2f17bb9f22b3ba61a83393a9794eaa5429 ?scala-reflect.jar
+344f3feafa4bd155b13ba7a6ab3efd605f8f8388 ?scala-reflect.jar
diff --git a/src/compiler/scala/reflect/makro/runtime/Context.scala b/src/compiler/scala/reflect/makro/runtime/Context.scala
index c7563e7b67..68964b7abb 100644
--- a/src/compiler/scala/reflect/makro/runtime/Context.scala
+++ b/src/compiler/scala/reflect/makro/runtime/Context.scala
@@ -8,7 +8,6 @@ abstract class Context extends scala.reflect.makro.Context
                          with CapturedVariables
                          with Infrastructure
                          with Enclosures
-                         with Mirrors
                          with Names
                          with Reifiers
                          with FrontEnds
@@ -23,7 +22,7 @@ abstract class Context extends scala.reflect.makro.Context
 
   val universe: Global
 
-  val mirror: MirrorOf[universe.type] = new ContextMirror
+  val mirror: MirrorOf[universe.type] = universe.rootMirror
 
   val callsiteTyper: universe.analyzer.Typer
 
diff --git a/src/compiler/scala/reflect/makro/runtime/ContextReifiers.scala b/src/compiler/scala/reflect/makro/runtime/ContextReifiers.scala
deleted file mode 100644
index 564148fe6c..0000000000
--- a/src/compiler/scala/reflect/makro/runtime/ContextReifiers.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-package scala.reflect.makro
-package runtime
-
-abstract class ContextReifiers { self =>
-  val c: Context
-
-  import c.universe._
-  import definitions._
-  import treeBuild._
-
-  import scala.reflect.reify.Taggers
-  import language.implicitConversions
-  private implicit def context2taggers(c0: Context) : Taggers { val c: c0.type } = new { val c: c0.type = c0 } with Taggers
-
-  private def forMacroContext[T](prefix: Tree)(op: (Tree, Tree) => T): T = {
-    val universe = gen.mkAttributedSelect(prefix.duplicate, MacroContextUniverse) setType SingleType(prefix.tpe, MacroContextUniverse)
-    val mirror = TypeApply(Select(Select(prefix.duplicate, nme.mirror), nme.asInstanceOf_), List(Select(Ident(nme.UNIVERSE_SHORT), tpnme.Mirror)))
-    op(universe, mirror)
-  }
-
-  def materializeExprForMacroContext(prefix: Tree, expr: Tree): Tree =
-    forMacroContext(prefix)((universe, mirror) => c.materializeExpr(universe, mirror, expr))
-
-  def materializeTypeTagForMacroContext(prefix: Tree, tpe: Type, concrete: Boolean): Tree =
-    forMacroContext(prefix)((universe, mirror) => c.materializeTypeTag(universe, mirror, tpe, concrete))
-}
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/makro/runtime/Mirrors.scala b/src/compiler/scala/reflect/makro/runtime/Mirrors.scala
deleted file mode 100644
index ec970ee696..0000000000
--- a/src/compiler/scala/reflect/makro/runtime/Mirrors.scala
+++ /dev/null
@@ -1,43 +0,0 @@
-package scala.reflect.makro
-package runtime
-
-import scala.tools.nsc.util.ScalaClassLoader
-
-trait Mirrors {
-  self: Context =>
-
-  import universe._
-  import definitions._
-
-  class ContextMirror extends RootsBase(NoSymbol) {
-    val universe: self.universe.type = self.universe
-    def rootLoader: LazyType = rootMirror.rootLoader
-
-    val RootPackage = rootMirror.RootPackage
-    val RootClass = rootMirror.RootClass
-    val EmptyPackage = rootMirror.EmptyPackage
-    val EmptyPackageClass = rootMirror.EmptyPackageClass
-
-    // [Eugene++] this still doesn't solve the problem of invoking `c.typeCheck` on the code that refers to packageless symbols
-    override protected def mirrorMissingHook(owner: Symbol, name: Name): Symbol = {
-      if (owner.isRoot && isJavaClass(name.toString)) EmptyPackageClass.info decl name
-      else NoSymbol
-    }
-
-    private lazy val libraryClasspathLoader: ClassLoader = {
-      val classpath = platform.classPath.asURLs
-      ScalaClassLoader.fromURLs(classpath)
-    }
-
-    private def isJavaClass(path: String): Boolean =
-      try {
-        Class.forName(path, true, libraryClasspathLoader)
-        true
-      } catch {
-        case (_: ClassNotFoundException) | (_: NoClassDefFoundError) | (_: IncompatibleClassChangeError) =>
-        false
-      }
-
-    override def toString = "macro context mirror"
-  }
-}
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/reify/Taggers.scala b/src/compiler/scala/reflect/reify/Taggers.scala
index e09f13a052..4e30d0acf8 100644
--- a/src/compiler/scala/reflect/reify/Taggers.scala
+++ b/src/compiler/scala/reflect/reify/Taggers.scala
@@ -37,23 +37,21 @@ abstract class Taggers {
   }
 
   def materializeTypeTag(universe: Tree, mirror: Tree, tpe: Type, concrete: Boolean): Tree = {
-    if (universe.symbol == MacroContextUniverse && mirror == EmptyTree) {
-      import scala.reflect.makro.runtime.ContextReifiers
-      import language.implicitConversions
-      implicit def context2contextreifiers(c0: Context) : ContextReifiers { val c: c0.type } = new { val c: c0.type = c0 } with ContextReifiers
-      val Select(prefix, _) = universe
-      c.materializeTypeTagForMacroContext(prefix, tpe, concrete)
-    } else {
-      val tagType = if (concrete) TypeTagClass else AbsTypeTagClass
-      val unaffiliatedTagTpe = TypeRef(BaseUniverseClass.asTypeConstructor, tagType, List(tpe))
-      val unaffiliatedTag = c.inferImplicitValue(unaffiliatedTagTpe, silent = true, withMacrosDisabled = true)
-      unaffiliatedTag match {
-        case success if !success.isEmpty =>
-          Apply(Select(success, nme.in), List(mirror orElse mkDefaultMirrorRef(c.universe)(universe, c.callsiteTyper)))
-        case _ =>
-          val tagModule = if (concrete) TypeTagModule else AbsTypeTagModule
-          materializeTag(universe, tpe, tagModule, c.reifyType(universe, mirror, tpe, concrete = concrete))
-      }
+    val tagType = if (concrete) TypeTagClass else AbsTypeTagClass
+    // what we need here is to compose a type BaseUniverse # TypeTag[$tpe]
+    // to look for an implicit that conforms to this type
+    // that's why neither appliedType(tagType, List(tpe)) aka TypeRef(TypeTagsClass.thisType, tagType, List(tpe))
+    // nor TypeRef(BaseUniverseClass.thisType, tagType, List(tpe)) won't fit here
+    // scala> :type -v def foo: scala.reflect.base.Universe#TypeTag[Int] = ???
+    // NullaryMethodType(TypeRef(pre = TypeRef(TypeSymbol(Universe)), TypeSymbol(TypeTag), args = List($tpe))))
+    val unaffiliatedTagTpe = TypeRef(BaseUniverseClass.typeConstructor, tagType, List(tpe))
+    val unaffiliatedTag = c.inferImplicitValue(unaffiliatedTagTpe, silent = true, withMacrosDisabled = true)
+    unaffiliatedTag match {
+      case success if !success.isEmpty =>
+        Apply(Select(success, nme.in), List(mirror orElse mkDefaultMirrorRef(c.universe)(universe, c.callsiteTyper)))
+      case _ =>
+        val tagModule = if (concrete) TypeTagModule else AbsTypeTagModule
+        materializeTag(universe, tpe, tagModule, c.reifyType(universe, mirror, tpe, concrete = concrete))
     }
   }
 
diff --git a/src/compiler/scala/reflect/reify/codegen/GenSymbols.scala b/src/compiler/scala/reflect/reify/codegen/GenSymbols.scala
index 9b0777580b..38c8fedac5 100644
--- a/src/compiler/scala/reflect/reify/codegen/GenSymbols.scala
+++ b/src/compiler/scala/reflect/reify/codegen/GenSymbols.scala
@@ -37,10 +37,40 @@ trait GenSymbols {
       mirrorMirrorSelect(nme.EmptyPackageClass)
     else if (sym.isModuleClass)
       Select(Select(reify(sym.sourceModule), nme.asModuleSymbol), nme.moduleClass)
+    else if (sym.isPackage)
+      mirrorMirrorCall(nme.staticPackage, reify(sym.fullName))
     else if (sym.isLocatable) {
-      // [Eugene] am I doing this right?
-//      if (sym.isStaticOwner) { // no good for us, because it returns false for packages
-      if (sym.isStatic && (sym.isClass || sym.isModule)) {
+      /** This is a fancy conundrum that stems from the fact that Scala allows
+       *  packageless packages and packageless objects with the same names in the same program.
+       *
+       *  For more details read the docs to staticModule and staticPackage.
+       *  Here I'll just provide the examples of how reify works for different kinds of symbols.
+       *
+       *    // 1) packageless
+       *    // packageless classes are non-ambiguous, but modules vs packages might be
+       *    // that's why we have separate methods to reify those
+       *    // note that staticModule will never resolve to a package if an object is missing and an homonymous package is present and vice versa
+       *    // otherwise reification would be unsound
+       *    class C => staticClass("C")
+       *    object B => staticModule("B")
+       *    package B => staticPackage("B")
+       *
+       *    // 2) classes and modules enclosed in a package
+       *    // staticXXX methods always look into parent packages and ignores parent modules, so for fully qualified names they are non-ambiguous
+       *    // namely even if there's an object B { class C } next to package B { class C }, then staticClass("B.C") will resolve to a packageful class
+       *    // this closely mirrors Scala's behavior, read up the docs to staticModule/staticPackage for more information
+       *    package B { class C } => staticClass("B.C")
+       *    package B { object B } => staticModule("B.B")
+       *    package B { package B } => staticPackage("B.B")
+       *
+       *    // 3) classes and modules enclosed in a packageless module
+       *    // staticClass/staticModule won't look into EmptyPackageClass, so we reify such symbols in a roundabout way
+       *    object B { class C } => selectType(staticModule("B"), "C")
+       *    object B { object B } => selectType(staticModule("B"), "B")
+       *    object B { package B } => impossible
+       */
+      val hasPackagelessParent = sym.ownerChain.tail.tail exists (_.isEmptyPackageClass)
+      if (sym.isStatic && (sym.isClass || sym.isModule) && !hasPackagelessParent) {
         val resolver = if (sym.isType) nme.staticClass else nme.staticModule
         mirrorMirrorCall(resolver, reify(sym.fullName))
       } else {
diff --git a/src/compiler/scala/reflect/reify/codegen/GenTypes.scala b/src/compiler/scala/reflect/reify/codegen/GenTypes.scala
index 82951a2434..c49e5b3342 100644
--- a/src/compiler/scala/reflect/reify/codegen/GenTypes.scala
+++ b/src/compiler/scala/reflect/reify/codegen/GenTypes.scala
@@ -41,8 +41,7 @@ trait GenTypes {
       case tpe @ ThisType(empty) if empty.isEmptyPackageClass =>
         mirrorBuildCall(nme.thisPrefix, mirrorMirrorSelect(nme.EmptyPackageClass))
       case tpe @ ThisType(clazz) if clazz.isModuleClass && clazz.isStatic =>
-        // [Eugene++ to Martin] makes sense?
-        val module = mirrorMirrorCall(nme.staticModule, reify(clazz.fullName))
+        val module = reify(clazz.sourceModule)
         val moduleClass = Select(Select(module, nme.asModuleSymbol), nme.moduleClass)
         mirrorFactoryCall(nme.ThisType, moduleClass)
       case tpe @ ThisType(_) =>
diff --git a/src/compiler/scala/reflect/reify/utils/Extractors.scala b/src/compiler/scala/reflect/reify/utils/Extractors.scala
index 52e4ff08c1..86265ec77a 100644
--- a/src/compiler/scala/reflect/reify/utils/Extractors.scala
+++ b/src/compiler/scala/reflect/reify/utils/Extractors.scala
@@ -27,7 +27,7 @@ trait Extractors {
   //       def applyImpl[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.base.MirrorOf[U]): U#Tree = {
   //         val $u: U = $m$untyped.universe;
   //         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
-  //         $u.Apply($u.Select($u.Select($u.build.This($m.staticModule("scala.collection.immutable").moduleClass), $u.newTermName("List")), $u.newTermName("apply")), List($u.Literal($u.Constant(1)), $u.Literal($u.Constant(2))))
+  //         $u.Apply($u.Select($u.Select($u.build.This($m.staticPackage("scala.collection.immutable").moduleClass), $u.newTermName("List")), $u.newTermName("apply")), List($u.Literal($u.Constant(1)), $u.Literal($u.Constant(2))))
   //       }
   //     };
   //     new $treecreator1()
@@ -40,7 +40,7 @@ trait Extractors {
   //       def apply[U >: Nothing <: scala.reflect.base.Universe with Singleton]($m$untyped: scala.reflect.base.MirrorOf[U]): U#Type = {
   //         val $u: U = $m$untyped.universe;
   //         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
-  //         $u.TypeRef($u.ThisType($m.staticModule("scala.collection.immutable").moduleClass), $m.staticClass("scala.collection.immutable.List"), List($m.staticClass("scala.Int").asTypeConstructor))
+  //         $u.TypeRef($u.ThisType($m.staticPackage("scala.collection.immutable").moduleClass), $m.staticClass("scala.collection.immutable.List"), List($m.staticClass("scala.Int").asTypeConstructor))
   //       }
   //     };
   //     new $typecreator1()
diff --git a/src/compiler/scala/tools/cmd/FromString.scala b/src/compiler/scala/tools/cmd/FromString.scala
index 29f1baaa0c..415940b3fd 100644
--- a/src/compiler/scala/tools/cmd/FromString.scala
+++ b/src/compiler/scala/tools/cmd/FromString.scala
@@ -8,7 +8,7 @@ package cmd
 
 import nsc.io.{ Path, File, Directory }
 import scala.reflect.runtime.{universe => ru}
-import scala.tools.reflect.StdTags._
+import scala.tools.reflect.StdRuntimeTags._
 
 /** A general mechanism for defining how a command line argument
  *  (always a String) is transformed into an arbitrary type.  A few
diff --git a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala
index e5e7d7081d..b567293a3f 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala
@@ -25,7 +25,7 @@ import ScalaClassLoader._
 import scala.tools.util._
 import language.{implicitConversions, existentials}
 import scala.reflect.{ClassTag, classTag}
-import scala.tools.reflect.StdTags._
+import scala.tools.reflect.StdRuntimeTags._
 
 /** The Scala interactive shell.  It provides a read-eval-print loop
  *  around the Interpreter class.
diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
index b385787cce..7bdbff8627 100644
--- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
@@ -28,7 +28,7 @@ import typechecker.Analyzer
 import language.implicitConversions
 import scala.reflect.runtime.{ universe => ru }
 import scala.reflect.{ ClassTag, classTag }
-import scala.tools.reflect.StdTags._
+import scala.tools.reflect.StdRuntimeTags._
 
 /** directory to save .class files to */
 private class ReplVirtualDirectory(out: JPrintWriter) extends VirtualDirectory("(memory)", None) {
diff --git a/src/compiler/scala/tools/reflect/FastTrack.scala b/src/compiler/scala/tools/reflect/FastTrack.scala
index 63ecfa32b2..237ef813c7 100644
--- a/src/compiler/scala/tools/reflect/FastTrack.scala
+++ b/src/compiler/scala/tools/reflect/FastTrack.scala
@@ -1,7 +1,6 @@
 package scala.tools
 package reflect
 
-import scala.reflect.makro.runtime.ContextReifiers
 import scala.reflect.reify.Taggers
 import scala.tools.nsc.typechecker.{Analyzer, Macros}
 
@@ -16,7 +15,6 @@ trait FastTrack {
 
   import language.implicitConversions
   private implicit def context2taggers(c0: MacroContext): Taggers { val c: c0.type } = new { val c: c0.type = c0 } with Taggers
-  private implicit def context2contextreifiers(c0: MacroContext): ContextReifiers { val c: c0.type } = new { val c: c0.type = c0 } with ContextReifiers
   private implicit def context2macroimplementations(c0: MacroContext): MacroImplementations { val c: c0.type } = new { val c: c0.type = c0 } with MacroImplementations
 
   implicit def fastTrackEntry2MacroRuntime(entry: FastTrackEntry): MacroRuntime = args => entry.run(args)
@@ -41,7 +39,6 @@ trait FastTrack {
     MacroInternal_materializeAbsTypeTag bindTo { case (c, Apply(TypeApply(_, List(tt)), List(u))) => c.materializeTypeTag(u, EmptyTree, tt.tpe, concrete = false) }
     MacroInternal_materializeTypeTag bindTo { case (c, Apply(TypeApply(_, List(tt)), List(u))) => c.materializeTypeTag(u, EmptyTree, tt.tpe, concrete = true) }
     ApiUniverseReify bindTo { case (c, Apply(TypeApply(_, List(tt)), List(expr))) => c.materializeExpr(c.prefix.tree, EmptyTree, expr) }
-    MacroContextReify bindTo { case (c, Apply(TypeApply(_, List(tt)), List(expr))) => c.materializeExprForMacroContext(c.prefix.tree, expr) }
     ReflectRuntimeCurrentMirror bindTo { case (c, _) => scala.reflect.runtime.Macros.currentMirror(c).tree }
     StringContext_f bindTo { case (c, app@Apply(Select(Apply(_, parts), _), args)) => c.macro_StringInterpolation_f(parts, args, app.pos) }
     registry
diff --git a/src/compiler/scala/tools/reflect/MacroImplementations.scala b/src/compiler/scala/tools/reflect/MacroImplementations.scala
index 604bd7cd1a..e1b959cefa 100644
--- a/src/compiler/scala/tools/reflect/MacroImplementations.scala
+++ b/src/compiler/scala/tools/reflect/MacroImplementations.scala
@@ -57,6 +57,9 @@ abstract class MacroImplementations {
       )
     }
 
+    val stdContextTags = new { val tc: c.type = c } with StdContextTags
+    import stdContextTags._
+
     def conversionType(ch: Char, arg: Tree): Option[Type] = {
       ch match {
         case 'b' | 'B' =>
@@ -68,11 +71,11 @@ abstract class MacroImplementations {
         case 'c' | 'C' =>
           checkType(arg, CharTpe, ByteTpe, ShortTpe, IntTpe)
         case 'd' | 'o' | 'x' | 'X' =>
-          checkType(arg, IntTpe, LongTpe, ByteTpe, ShortTpe, typeOf[BigInt])
+          checkType(arg, IntTpe, LongTpe, ByteTpe, ShortTpe, tagOfBigInt.tpe)
         case 'e' | 'E' | 'g' | 'G' | 'f' | 'a' | 'A'  =>
-          checkType(arg, DoubleTpe, FloatTpe, typeOf[BigDecimal])
+          checkType(arg, DoubleTpe, FloatTpe, tagOfBigDecimal.tpe)
         case 't' | 'T' =>
-          checkType(arg, LongTpe, typeOf[java.util.Calendar], typeOf[java.util.Date])
+          checkType(arg, LongTpe, tagOfCalendar.tpe, tagOfDate.tpe)
         case _ => None
       }
     }
diff --git a/src/compiler/scala/tools/reflect/StdTags.scala b/src/compiler/scala/tools/reflect/StdTags.scala
index 18cbf9c4b7..25a42a82cd 100644
--- a/src/compiler/scala/tools/reflect/StdTags.scala
+++ b/src/compiler/scala/tools/reflect/StdTags.scala
@@ -4,46 +4,55 @@ package reflect
 import java.lang.{Class => jClass}
 import scala.reflect.{ClassTag, classTag}
 import scala.reflect.base.{MirrorOf, TypeCreator, Universe => BaseUniverse}
-import scala.reflect.runtime.{universe => ru}
 
 // [Eugene++] Before 2.10 is released, I suggest we don't rely on automated type tag generation
 // sure, it's convenient, but then refactoring reflection / reification becomes a pain
 // `ClassTag` tags are fine, because they don't need a reifier to be generated
 
-object StdTags {
-  // root mirror is fine for these guys, since scala-library.jar is guaranteed to be reachable from the root mirror
-  lazy val tagOfString = ru.TypeTag[String](
-    ru.rootMirror,
-    new TypeCreator {
-      def apply[U <: BaseUniverse with Singleton](m: MirrorOf[U]): U # Type = {
-        val u = m.universe
-        u.definitions.StringClass.asTypeConstructor
-      }
-    })
-  lazy val tagOfListOfString = ru.TypeTag[List[String]](
-    ru.rootMirror,
-    new TypeCreator {
-      def apply[U <: BaseUniverse with Singleton](m: MirrorOf[U]): U # Type = {
-        val u = m.universe
-        val pre = u.ThisType(m.staticModule("scala.collection.immutable").moduleClass.asInstanceOf[u.Symbol])
-        u.TypeRef(pre, u.definitions.ListClass, List(u.definitions.StringClass.asTypeConstructor))
-      }
-    })
+trait StdTags {
+  val u: BaseUniverse with Singleton
+  val m: MirrorOf[u.type]
 
-  // root mirror is NOT fine for these guys, hence we use the `currentMirror` trick
-  private val ourClassloader = getClass.getClassLoader
-  private def tagOfStaticClass[T: ClassTag] =
-    ru.TypeTag[T](
-      ru.runtimeMirror(ourClassloader),
+  lazy val tagOfListOfString: u.TypeTag[List[String]] =
+    u.TypeTag[List[String]](
+      m,
+      new TypeCreator {
+        def apply[U <: BaseUniverse with Singleton](m: MirrorOf[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.asTypeConstructor))
+        }
+      })
+
+  private def tagOfStaticClass[T: ClassTag]: u.TypeTag[T] =
+    u.TypeTag[T](
+      m,
       new TypeCreator {
         def apply[U <: BaseUniverse with Singleton](m: MirrorOf[U]): U # Type =
           m.staticClass(classTag[T].runtimeClass.getName).asTypeConstructor.asInstanceOf[U # Type]
       })
-  lazy val tagOfInt = ru.TypeTag.Int
+  lazy val tagOfInt = u.TypeTag.Int
+  lazy val tagOfString = tagOfStaticClass[String]
   lazy val tagOfFile = tagOfStaticClass[scala.tools.nsc.io.File]
   lazy val tagOfDirectory = tagOfStaticClass[scala.tools.nsc.io.Directory]
   lazy val tagOfStdReplVals = tagOfStaticClass[scala.tools.nsc.interpreter.StdReplVals]
   lazy val tagOfIMain = tagOfStaticClass[scala.tools.nsc.interpreter.IMain]
   lazy val tagOfThrowable = tagOfStaticClass[java.lang.Throwable]
   lazy val tagOfClassLoader = tagOfStaticClass[java.lang.ClassLoader]
+  lazy val tagOfBigInt = tagOfStaticClass[BigInt]
+  lazy val tagOfBigDecimal = tagOfStaticClass[BigDecimal]
+  lazy val tagOfCalendar = tagOfStaticClass[java.util.Calendar]
+  lazy val tagOfDate = tagOfStaticClass[java.util.Date]
+}
+
+object StdRuntimeTags extends StdTags {
+  val u: scala.reflect.runtime.universe.type = scala.reflect.runtime.universe
+  val m = u.runtimeMirror(getClass.getClassLoader)
+  // we need getClass.getClassLoader to support the stuff from scala-compiler.jar
+}
+
+abstract class StdContextTags extends StdTags {
+  val tc: scala.reflect.makro.Context
+  val u: tc.universe.type = tc.universe
+  val m = tc.mirror
 }
diff --git a/src/continuations/plugin/scala/tools/selectivecps/CPSUtils.scala b/src/continuations/plugin/scala/tools/selectivecps/CPSUtils.scala
index 3a1dc87a6a..46c644bcd6 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/CPSUtils.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/CPSUtils.scala
@@ -36,7 +36,7 @@ trait CPSUtils {
   lazy val MarkerCPSAdaptMinus = rootMirror.getRequiredClass("scala.util.continuations.cpsMinus")
 
   lazy val Context = rootMirror.getRequiredClass("scala.util.continuations.ControlContext")
-  lazy val ModCPS = rootMirror.getRequiredModule("scala.util.continuations")
+  lazy val ModCPS = rootMirror.getRequiredPackage("scala.util.continuations")
 
   lazy val MethShiftUnit  = definitions.getMember(ModCPS, cpsNames.shiftUnit)
   lazy val MethShiftUnit0 = definitions.getMember(ModCPS, cpsNames.shiftUnit0)
diff --git a/src/library/scala/reflect/base/Base.scala b/src/library/scala/reflect/base/Base.scala
index a4e6256f4d..4457a6cf14 100644
--- a/src/library/scala/reflect/base/Base.scala
+++ b/src/library/scala/reflect/base/Base.scala
@@ -357,6 +357,9 @@ class Base extends Universe { self =>
     def staticModule(fullName: String): ModuleSymbol =
       mkStatic[ModuleSymbol](fullName)
 
+    def staticPackage(fullName: String): ModuleSymbol =
+      staticModule(fullName) // this toy universe doesn't care about the distinction between packages and modules
+
     private def mkStatic[S <: Symbol : ClassTag](fullName: String): S =
       cached(fullName) {
         val point = fullName lastIndexOf '.'
diff --git a/src/library/scala/reflect/base/MirrorOf.scala b/src/library/scala/reflect/base/MirrorOf.scala
index 03e035cd81..6dc8090eee 100644
--- a/src/library/scala/reflect/base/MirrorOf.scala
+++ b/src/library/scala/reflect/base/MirrorOf.scala
@@ -15,11 +15,76 @@ abstract class MirrorOf[U <: base.Universe with Singleton] {
 
   /** The symbol corresponding to the globally accessible class with the
    *  given fully qualified name `fullName`.
+   *
+   *  If the name points to a type alias, it's recursively dealiased and its target is returned.
+   *  If you need a symbol that corresponds to the type alias itself, load it directly from the package class:
+   *
+   *    scala> cm.staticClass("scala.List")
+   *    res0: reflect.runtime.universe.ClassSymbol = class List
+   *
+   *    scala> res0.fullName
+   *    res1: String = scala.collection.immutable.List
+   *
+   *    scala> cm.staticPackage("scala")
+   *    res2: reflect.runtime.universe.ModuleSymbol = package scala
+   *
+   *    scala> res2.moduleClass.typeSignature member newTypeName("List")
+   *    res3: reflect.runtime.universe.Symbol = type List
+   *
+   *    scala> res3.fullName
+   *    res4: String = scala.List
+   *
+   *  To be consistent with Scala name resolution rules, in case of ambiguity between
+   *  a package and an object, the object is never been considered.
+   *
+   *  For example for the following code:
+   *
+   *    package foo {
+   *      class B
+   *    }
+   *
+   *    object foo {
+   *      class A
+   *      class B
+   *    }
+   *
+   *  staticClass("foo.B") will resolve to the symbol corresponding to the class B declared in the package foo, and
+   *  staticClass("foo.A") will throw a MissingRequirementException (which is exactly what scalac would do if this
+   *  fully qualified class name is written inside any package in a Scala program).
+   *
+   *  In the example above, to load a symbol that corresponds to the class B declared in the object foo,
+   *  use staticModule("foo") to load the module symbol and then navigate typeSignature.members of its moduleClass.
    */
   def staticClass(fullName: String): U#ClassSymbol
 
   /** The symbol corresponding to the globally accessible object with the
    *  given fully qualified name `fullName`.
+   *
+   *  To be consistent with Scala name resolution rules, in case of ambiguity between
+   *  a package and an object, the object is never been considered.
+   *
+   *  For example for the following code:
+   *
+   *    package foo {
+   *      object B
+   *    }
+   *
+   *    object foo {
+   *      object A
+   *      object B
+   *    }
+   *
+   *  staticModule("foo.B") will resolve to the symbol corresponding to the object B declared in the package foo, and
+   *  staticModule("foo.A") will throw a MissingRequirementException (which is exactly what scalac would do if this
+   *  fully qualified class name is written inside any package in a Scala program).
+   *
+   *  In the example above, to load a symbol that corresponds to the object B declared in the object foo,
+   *  use staticModule("foo") to load the module symbol and then navigate typeSignature.members of its moduleClass.
    */
   def staticModule(fullName: String): U#ModuleSymbol
+
+  /** The symbol corresponding to a package with the
+   *  given fully qualified name `fullName`.
+   */
+  def staticPackage(fullName: String): U#ModuleSymbol
 }
diff --git a/src/partest/scala/tools/partest/CompilerTest.scala b/src/partest/scala/tools/partest/CompilerTest.scala
index 89c1a9c2ca..fec9893099 100644
--- a/src/partest/scala/tools/partest/CompilerTest.scala
+++ b/src/partest/scala/tools/partest/CompilerTest.scala
@@ -50,7 +50,7 @@ abstract class CompilerTest extends DirectTest {
   }
 
   class SymsInPackage(pkgName: String) {
-    def pkg     = rootMirror.getRequiredModule(pkgName)
+    def pkg     = rootMirror.getRequiredPackage(pkgName)
     def classes = allMembers(pkg) filter (_.isClass)
     def modules = allMembers(pkg) filter (_.isModule)
     def symbols = classes ++ terms filterNot (_ eq NoSymbol)
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index cd243b9df0..7284a199b7 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -490,7 +490,6 @@ trait Definitions extends api.StandardDefinitions {
          def MacroContextPrefixType              = if (MacroContextClass != NoSymbol) getMemberType(MacroContextClass, tpnme.PrefixType) else NoSymbol
          def MacroContextUniverse                = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.universe) else NoSymbol
          def MacroContextMirror                  = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.mirror) else NoSymbol
-         def MacroContextReify                   = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.reify) else NoSymbol
     lazy val MacroImplAnnotation                 = requiredClass[scala.reflect.makro.internal.macroImpl]
     lazy val MacroInternalPackage                = getPackageObject("scala.reflect.makro.internal")
          def MacroInternal_materializeClassTag   = getMemberMethod(MacroInternalPackage, nme.materializeClassTag)
diff --git a/src/reflect/scala/reflect/internal/Mirrors.scala b/src/reflect/scala/reflect/internal/Mirrors.scala
index 761b993539..f7561ae274 100644
--- a/src/reflect/scala/reflect/internal/Mirrors.scala
+++ b/src/reflect/scala/reflect/internal/Mirrors.scala
@@ -36,7 +36,7 @@ trait Mirrors extends api.Mirrors {
         if (point > 0) getModuleOrClass(path.toTermName, point)
         else RootClass
       val name = path subName (point + 1, len)
-      val sym = owner.info member name
+      var sym = owner.info member name
       val result = if (path.isTermName) sym.suchThat(_ hasFlag MODULE) else sym
       if (result != NoSymbol) result
       else {
@@ -47,23 +47,39 @@ trait Mirrors extends api.Mirrors {
       }
     }
 
-    protected def mirrorMissingHook(owner: Symbol, name: Name): Symbol = NoSymbol
-
-    protected def symbolTableMissingHook(owner: Symbol, name: Name): Symbol = self.missingHook(owner, name)
-
-    private[scala] def missingHook(owner: Symbol, name: Name): Symbol = mirrorMissingHook(owner, name) orElse symbolTableMissingHook(owner, name)
+    /** If you're looking for a class, pass a type name.
+     *  If a module, a term name.
+     *
+     *  Unlike `getModuleOrClass`, this function
+     *  loads unqualified names from the root package.
+     */
+    private def getModuleOrClass(path: Name): Symbol =
+      getModuleOrClass(path, path.length)
 
     /** If you're looking for a class, pass a type name.
      *  If a module, a term name.
+     *
+     *  Unlike `getModuleOrClass`, this function
+     *  loads unqualified names from the empty package.
      */
-    private def getModuleOrClass(path: Name): Symbol = getModuleOrClass(path, path.length)
+    private def staticModuleOrClass(path: Name): Symbol = {
+      val isPackageless = path.pos('.') == path.length
+      if (isPackageless) EmptyPackageClass.info decl path
+      else getModuleOrClass(path)
+    }
+
+    protected def mirrorMissingHook(owner: Symbol, name: Name): Symbol = NoSymbol
+
+    protected def universeMissingHook(owner: Symbol, name: Name): Symbol = self.missingHook(owner, name)
 
-    override def staticClass(fullName: String): ClassSymbol = getRequiredClass(fullName)
+    private[scala] def missingHook(owner: Symbol, name: Name): Symbol = mirrorMissingHook(owner, name) orElse universeMissingHook(owner, name)
 
-    // todo: get rid of most creation methods and keep just staticClass/Module/Package
+    // todo: get rid of most the methods here and keep just staticClass/Module/Package
 
-    def getClassByName(fullname: Name): ClassSymbol = {
-      var result = getModuleOrClass(fullname.toTypeName)
+    /************************ loaders of class symbols ************************/
+
+    private def ensureClassSymbol(fullname: String, sym: Symbol): ClassSymbol = {
+      var result = sym
       while (result.isAliasType) result = result.info.typeSymbol
       result match {
         case x: ClassSymbol => x
@@ -71,45 +87,50 @@ trait Mirrors extends api.Mirrors {
       }
     }
 
-    override def staticModule(fullName: String): ModuleSymbol = getRequiredModule(fullName)
+    @deprecated("Use getClassByName", "2.10.0")
+    def getClass(fullname: Name): ClassSymbol =
+      getClassByName(fullname)
 
-    def getModule(fullname: Name): ModuleSymbol =
-      // [Eugene++] should be a ClassCastException instead?
-      getModuleOrClass(fullname.toTermName) match {
-        case x: ModuleSymbol => x
-        case _               => MissingRequirementError.notFound("object " + fullname)
-      }
+    def getClassByName(fullname: Name): ClassSymbol =
+      ensureClassSymbol(fullname.toString, getModuleOrClass(fullname.toTypeName))
 
-    def getPackage(fullname: Name): ModuleSymbol = getModule(fullname)
+    def getRequiredClass(fullname: String): ClassSymbol =
+      getClassByName(newTypeNameCached(fullname))
 
-    def getRequiredPackage(fullname: String): ModuleSymbol =
-      getPackage(newTermNameCached(fullname))
+    def requiredClass[T: ClassTag] : ClassSymbol =
+      getRequiredClass(erasureName[T])
 
-    @deprecated("Use getClassByName", "2.10.0")
-    def getClass(fullname: Name): ClassSymbol = getClassByName(fullname)
+    def getClassIfDefined(fullname: String): Symbol =
+      getClassIfDefined(newTypeNameCached(fullname))
 
-    def getRequiredClass(fullname: String): ClassSymbol =
-      getClassByName(newTypeNameCached(fullname)) match {
-        case x: ClassSymbol => x
-        case _              => MissingRequirementError.notFound("class " + fullname)
-      }
+    def getClassIfDefined(fullname: Name): Symbol =
+      wrapMissing(getClassByName(fullname.toTypeName))
 
-    def getRequiredModule(fullname: String): ModuleSymbol =
-      getModule(newTermNameCached(fullname))
+    /** @inheritdoc
+     *
+     *  Unlike getClassByName/getRequiredClass this function can also load packageless symbols.
+     *  Compiler might ignore them, but they should be loadable with macros.
+     */
+    override def staticClass(fullname: String): ClassSymbol =
+      ensureClassSymbol(fullname, staticModuleOrClass(newTypeNameCached(fullname)))
 
-    def erasureName[T: ClassTag] : String = {
-      /** We'd like the String representation to be a valid
-       *  scala type, so we have to decode the jvm's secret language.
-       */
-      def erasureString(clazz: Class[_]): String = {
-        if (clazz.isArray) "Array[" + erasureString(clazz.getComponentType) + "]"
-        else clazz.getName
+    /************************ loaders of module symbols ************************/
+
+    private def ensureModuleSymbol(fullname: String, sym: Symbol, allowPackages: Boolean): ModuleSymbol =
+      sym match {
+        case x: ModuleSymbol if allowPackages || !x.isPackage => x
+        case _                                                => MissingRequirementError.notFound("object " + fullname)
       }
-      erasureString(classTag[T].runtimeClass)
-    }
 
-    def requiredClass[T: ClassTag] : ClassSymbol =
-      getRequiredClass(erasureName[T])
+    @deprecated("Use getModuleByName", "2.10.0")
+    def getModule(fullname: Name): ModuleSymbol =
+      getModuleByName(fullname)
+
+    def getModuleByName(fullname: Name): ModuleSymbol =
+      ensureModuleSymbol(fullname.toString, getModuleOrClass(fullname.toTermName), allowPackages = true)
+
+    def getRequiredModule(fullname: String): ModuleSymbol =
+      getModule(newTermNameCached(fullname))
 
     // TODO: What syntax do we think should work here? Say you have an object
     // like scala.Predef.  You can't say requiredModule[scala.Predef] since there's
@@ -121,34 +142,60 @@ trait Mirrors extends api.Mirrors {
     def requiredModule[T: ClassTag] : ModuleSymbol =
       getRequiredModule(erasureName[T] stripSuffix "$")
 
-    def getClassIfDefined(fullname: String): Symbol =
-      getClassIfDefined(newTypeName(fullname))
-
-    def getClassIfDefined(fullname: Name): Symbol =
-      wrapMissing(getClassByName(fullname.toTypeName))
-
     def getModuleIfDefined(fullname: String): Symbol =
-      getModuleIfDefined(newTermName(fullname))
+      getModuleIfDefined(newTermNameCached(fullname))
 
     def getModuleIfDefined(fullname: Name): Symbol =
       wrapMissing(getModule(fullname.toTermName))
 
+    /** @inheritdoc
+     *
+     *  Unlike getModule/getRequiredModule this function can also load packageless symbols.
+     *  Compiler might ignore them, but they should be loadable with macros.
+     */
+    override def staticModule(fullname: String): ModuleSymbol =
+      ensureModuleSymbol(fullname, staticModuleOrClass(newTermNameCached(fullname)), allowPackages = false)
+
+    /************************ loaders of package symbols ************************/
+
+    private def ensurePackageSymbol(fullname: String, sym: Symbol, allowModules: Boolean): ModuleSymbol =
+      sym match {
+        case x: ModuleSymbol if allowModules || x.isPackage => x
+        case _                                              => MissingRequirementError.notFound("package " + fullname)
+      }
+
+    def getPackage(fullname: Name): ModuleSymbol =
+      ensurePackageSymbol(fullname.toString, getModuleOrClass(fullname), allowModules = true)
+
+    def getRequiredPackage(fullname: String): ModuleSymbol =
+      getPackage(newTermNameCached(fullname))
+
     def getPackageObject(fullname: String): ModuleSymbol =
-      (getModule(newTermName(fullname)).info member nme.PACKAGE) match {
+      (getPackage(newTermName(fullname)).info member nme.PACKAGE) match {
         case x: ModuleSymbol => x
         case _               => MissingRequirementError.notFound("package object " + fullname)
       }
 
-    def getPackageObjectIfDefined(fullname: String): Symbol = {
-      val module = getModuleIfDefined(newTermName(fullname))
-      if (module == NoSymbol) NoSymbol
-      else {
-        val packageObject = module.info member nme.PACKAGE
-        packageObject match {
-          case x: ModuleSymbol => x
-          case _               => NoSymbol
-        }
+    def getPackageObjectIfDefined(fullname: String): Symbol =
+      getPackageObjectIfDefined(newTermNameCached(fullname))
+
+    def getPackageObjectIfDefined(fullname: Name): Symbol =
+      wrapMissing(getPackageObject(fullname.toTermName))
+
+    override def staticPackage(fullname: String): ModuleSymbol =
+      ensurePackageSymbol(fullname.toString, getModuleOrClass(newTermNameCached(fullname)), allowModules = false)
+
+    /************************ helpers ************************/
+
+    def erasureName[T: ClassTag] : String = {
+      /** We'd like the String representation to be a valid
+       *  scala type, so we have to decode the jvm's secret language.
+       */
+      def erasureString(clazz: Class[_]): String = {
+        if (clazz.isArray) "Array[" + erasureString(clazz.getComponentType) + "]"
+        else clazz.getName
       }
+      erasureString(classTag[T].runtimeClass)
     }
 
    @inline private def wrapMissing(body: => Symbol): Symbol =
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index c8a2424118..e5d0e96d9c 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -754,6 +754,7 @@ trait StdNames {
     val splice: NameType               = "splice"
     val staticClass : NameType         = "staticClass"
     val staticModule : NameType        = "staticModule"
+    val staticPackage : NameType       = "staticPackage"
     val synchronized_ : NameType       = "synchronized"
     val tail: NameType                 = "tail"
     val `then` : NameType              = "then"
diff --git a/src/reflect/scala/reflect/makro/Context.scala b/src/reflect/scala/reflect/makro/Context.scala
index f9858a063c..f093016a38 100644
--- a/src/reflect/scala/reflect/makro/Context.scala
+++ b/src/reflect/scala/reflect/makro/Context.scala
@@ -33,8 +33,4 @@ trait Context extends Aliases
 
   /** The prefix tree from which the macro is selected */
   val prefix: Expr[PrefixType]
-
-  /** Alias to the underlying mirror's reify */
-  // implementation is magically hardwired to `scala.reflect.makro.runtime.ContextReifiers`
-  def reify[T](expr: T): Expr[T] = macro ???
 }
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index 9f9f79058d..0878801715 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -72,6 +72,18 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
       override def complete(sym: Symbol) = sym setInfo new LazyPackageType
     }
 
+    // reflective mirrors can't know the exhaustive list of available packages
+    // (that's because compiler mirrors are based on directories and reflective mirrors are based on classloaders,
+    // and unlike directories classloaders might make up stuff on the fly)
+    // hence we need to be optimistic and create packages out of thin air
+    // the same thing is done by the `missingHook` below
+    override def staticPackage(fullname: String): ModuleSymbol =
+      try super.staticPackage(fullname)
+      catch {
+        case _: MissingRequirementError =>
+          makeScalaPackage(fullname)
+      }
+
 // ----------- Caching ------------------------------------------------------------------
 
     // [Eugene++ to Martin] not weak? why?
diff --git a/test/files/neg/macro-cyclic.check b/test/files/neg/macro-cyclic.check
index 608381e0e8..7978ec64a5 100644
--- a/test/files/neg/macro-cyclic.check
+++ b/test/files/neg/macro-cyclic.check
@@ -1,4 +1,4 @@
-Impls_Macros_1.scala:5: error: could not find implicit value for parameter e: SourceLocation

-    c.reify { implicitly[SourceLocation] }

-                        ^

-one error found

+Impls_Macros_1.scala:5: error: could not find implicit value for parameter e: SourceLocation
+    c.universe.reify { implicitly[SourceLocation] }
+                                 ^
+one error found
diff --git a/test/files/neg/macro-cyclic/Impls_Macros_1.scala b/test/files/neg/macro-cyclic/Impls_Macros_1.scala
index 1ea06fc968..2ecdc3416e 100644
--- a/test/files/neg/macro-cyclic/Impls_Macros_1.scala
+++ b/test/files/neg/macro-cyclic/Impls_Macros_1.scala
@@ -2,7 +2,7 @@ import scala.reflect.makro.Context
 
 object Macros {
   def impl(c: Context) = {
-    c.reify { implicitly[SourceLocation] }
+    c.universe.reify { implicitly[SourceLocation] }
   }
 
   implicit def sourceLocation: SourceLocation1 = macro impl
diff --git a/test/files/run/existentials-in-compiler.scala b/test/files/run/existentials-in-compiler.scala
index 1f314aa4e0..c69d1217fd 100644
--- a/test/files/run/existentials-in-compiler.scala
+++ b/test/files/run/existentials-in-compiler.scala
@@ -72,7 +72,7 @@ package extest {
   """
 
   def check(source: String, unit: global.CompilationUnit) = {
-    getRequiredModule("extest").moduleClass.info.decls.toList.filter(_.isType).map(_.initialize).sortBy(_.name.toString) foreach { clazz =>
+    getRequiredPackage("extest").moduleClass.info.decls.toList.filter(_.isType).map(_.initialize).sortBy(_.name.toString) foreach { clazz =>
       afterTyper {
         clazz.info
         println(clazz.defString)
diff --git a/test/files/run/macro-openmacros/Impls_Macros_1.scala b/test/files/run/macro-openmacros/Impls_Macros_1.scala
index ffeccce1e8..6b92834b81 100644
--- a/test/files/run/macro-openmacros/Impls_Macros_1.scala
+++ b/test/files/run/macro-openmacros/Impls_Macros_1.scala
@@ -16,7 +16,7 @@ object Macros {
 
     import c.universe._
     val next = if (c.enclosingMacros.length < 3) c.Expr[Unit](Select(Ident(c.mirror.staticModule("Macros")), newTermName("foo"))) else c.literalUnit
-    c.reify {
+    c.universe.reify {
       println(c.literal(normalizePaths(c.enclosingMacros.toString)).splice)
       next.splice
     }
diff --git a/test/files/run/macro-reify-basic/Macros_1.scala b/test/files/run/macro-reify-basic/Macros_1.scala
index 7a43ee58be..8f8598e248 100644
--- a/test/files/run/macro-reify-basic/Macros_1.scala
+++ b/test/files/run/macro-reify-basic/Macros_1.scala
@@ -4,7 +4,7 @@ object Macros {
   def foo(s: String) = macro Impls.foo
 
   object Impls {
-    def foo(c: Ctx)(s: c.Expr[String]) = c.reify {
+    def foo(c: Ctx)(s: c.Expr[String]) = c.universe.reify {
       println("hello " + s.splice)
     }
   }
diff --git a/test/files/run/macro-reify-freevars/Macros_1.scala b/test/files/run/macro-reify-freevars/Macros_1.scala
index eafc7f9a82..df1473511d 100644
--- a/test/files/run/macro-reify-freevars/Macros_1.scala
+++ b/test/files/run/macro-reify-freevars/Macros_1.scala
@@ -7,7 +7,7 @@ object QueryableMacros{
          : c.Expr[scala.collection.slick.Queryable[S]] = {
     import c.universe._
     val code = EmptyTree
-    c.reify{
+    c.universe.reify{
       Queryable.factory[S]( code.asInstanceOf[reflect.runtime.universe.Tree] )
     }
   }
diff --git a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala
index f9a08df90d..b52b962e31 100644
--- a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala
+++ b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala
@@ -30,7 +30,7 @@ object QueryableMacros{
         Apply(Select(c.prefix.tree, newTermName( name )), List( projection.tree ))
        ).asInstanceOf[Tree]
       )))
-    c.reify{ Queryable.factory[S]( foo.splice )}
+    c.universe.reify{ Queryable.factory[S]( foo.splice )}
   }
   def map[T:c.TypeTag, S:c.TypeTag]
                (c: scala.reflect.makro.Context)
diff --git a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala
index f9a08df90d..b52b962e31 100644
--- a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala
+++ b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala
@@ -30,7 +30,7 @@ object QueryableMacros{
         Apply(Select(c.prefix.tree, newTermName( name )), List( projection.tree ))
        ).asInstanceOf[Tree]
       )))
-    c.reify{ Queryable.factory[S]( foo.splice )}
+    c.universe.reify{ Queryable.factory[S]( foo.splice )}
   }
   def map[T:c.TypeTag, S:c.TypeTag]
                (c: scala.reflect.makro.Context)
diff --git a/test/files/run/macro-reify-ref-to-packageless/Impls_1.scala b/test/files/run/macro-reify-ref-to-packageless/Impls_1.scala
index 2f2d05678d..66c0ee1e9b 100644
--- a/test/files/run/macro-reify-ref-to-packageless/Impls_1.scala
+++ b/test/files/run/macro-reify-ref-to-packageless/Impls_1.scala
@@ -2,5 +2,5 @@ import scala.reflect.makro.{Context => Ctx}
 
 object Impls {
   val `Answer to the Ultimate Question of Life, the Universe, and Everything` = 42
-  def foo(c: Ctx) = c.reify { `Answer to the Ultimate Question of Life, the Universe, and Everything` }
+  def foo(c: Ctx) = c.universe.reify { `Answer to the Ultimate Question of Life, the Universe, and Everything` }
 }
diff --git a/test/files/run/macro-reify-splice-splice/Macros_1.scala b/test/files/run/macro-reify-splice-splice/Macros_1.scala
index 4f1b600f63..0de780b5a2 100644
--- a/test/files/run/macro-reify-splice-splice/Macros_1.scala
+++ b/test/files/run/macro-reify-splice-splice/Macros_1.scala
@@ -4,8 +4,8 @@ object Macros {
   def foo = macro Impls.foo
 
   object Impls {
-    def foo(c: Ctx) = c.reify {
-      { c.reify(c.reify("hello world")) }.splice.splice
+    def foo(c: Ctx) = c.universe.reify {
+      { c.universe.reify(c.universe.reify("hello world")) }.splice.splice
     }
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-reify-staticXXX.check b/test/files/run/macro-reify-staticXXX.check
new file mode 100644
index 0000000000..2894fa5843
--- /dev/null
+++ b/test/files/run/macro-reify-staticXXX.check
@@ -0,0 +1,12 @@
+object
+class
+object > object
+object > class
+package > object
+package > class
+object
+class
+object > object
+object > class
+package > object
+package > class
\ No newline at end of file
diff --git a/test/files/run/macro-reify-staticXXX.flags b/test/files/run/macro-reify-staticXXX.flags
new file mode 100644
index 0000000000..cd66464f2f
--- /dev/null
+++ b/test/files/run/macro-reify-staticXXX.flags
@@ -0,0 +1 @@
+-language:experimental.macros
\ No newline at end of file
diff --git a/test/files/run/macro-reify-staticXXX/Macros_1.scala b/test/files/run/macro-reify-staticXXX/Macros_1.scala
new file mode 100644
index 0000000000..b0ce6507f8
--- /dev/null
+++ b/test/files/run/macro-reify-staticXXX/Macros_1.scala
@@ -0,0 +1,48 @@
+import scala.reflect.makro.Context
+
+object B { override def toString = "object" }
+class C { override def toString = "class" }
+
+package foo {
+  object B { override def toString = "package > object" }
+  class C { override def toString = "package > class" }
+}
+
+object foo {
+  object B { override def toString = "object > object" }
+  class C { override def toString = "object > class" }
+}
+
+object packageless {
+  def impl(c: Context) = {
+    import c.universe._
+    reify {
+      println(B)
+      println(new C)
+      println(foo.B)
+      println(new foo.C)
+      println(_root_.foo.B)
+      println(new _root_.foo.C)
+    }
+  }
+
+  def test = macro impl
+}
+
+package packageful {
+  object Test {
+    def impl(c: Context) = {
+      import c.universe._
+      reify {
+        println(B)
+        println(new C)
+        println(foo.B)
+        println(new foo.C)
+        println(_root_.foo.B)
+        println(new _root_.foo.C)
+      }
+    }
+
+    def test = macro impl
+  }
+}
diff --git a/test/files/run/macro-reify-staticXXX/Test_2.scala b/test/files/run/macro-reify-staticXXX/Test_2.scala
new file mode 100644
index 0000000000..6e8cc36080
--- /dev/null
+++ b/test/files/run/macro-reify-staticXXX/Test_2.scala
@@ -0,0 +1,4 @@
+object Test extends App {
+  packageless.test
+  packageful.Test.test
+}
diff --git a/test/files/run/macro-reify-tagful-a/Macros_1.scala b/test/files/run/macro-reify-tagful-a/Macros_1.scala
index 63f117220a..32b09bdcdf 100644
--- a/test/files/run/macro-reify-tagful-a/Macros_1.scala
+++ b/test/files/run/macro-reify-tagful-a/Macros_1.scala
@@ -5,7 +5,7 @@ object Macros {
   def foo[T](s: T) = macro Impls.foo[T]
 
   object Impls {
-    def foo[T: c.TypeTag](c: Ctx)(s: c.Expr[T]) = c.reify {
+    def foo[T: c.TypeTag](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
       List(s.splice)
     }
   }
diff --git a/test/files/run/macro-reify-tagless-a/Impls_Macros_1.scala b/test/files/run/macro-reify-tagless-a/Impls_Macros_1.scala
index 3796ae99cb..77e4b729d3 100644
--- a/test/files/run/macro-reify-tagless-a/Impls_Macros_1.scala
+++ b/test/files/run/macro-reify-tagless-a/Impls_Macros_1.scala
@@ -4,7 +4,7 @@ object Macros {
   def foo[T](s: T) = macro Impls.foo[T]
 
   object Impls {
-    def foo[T](c: Ctx)(s: c.Expr[T]) = c.reify {
+    def foo[T](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
       List[T](s.splice)
     }
   }
diff --git a/test/files/run/macro-reify-unreify/Macros_1.scala b/test/files/run/macro-reify-unreify/Macros_1.scala
index 14777506d3..3e9033966d 100644
--- a/test/files/run/macro-reify-unreify/Macros_1.scala
+++ b/test/files/run/macro-reify-unreify/Macros_1.scala
@@ -11,7 +11,7 @@ object Macros {
       val greeting = c.reifyTree(c.runtimeUniverse, EmptyTree, c.typeCheck(Apply(Select(Literal(Constant("hello ")), newTermName("$plus")), List(c.unreifyTree(world)))))
       val typedGreeting = c.Expr[String](greeting)
 
-      c.reify {
+      c.universe.reify {
         println("hello " + s.splice + " = " + typedGreeting.splice)
       }
     }
diff --git a/test/files/run/macro-settings/Impls_Macros_1.scala b/test/files/run/macro-settings/Impls_Macros_1.scala
index 56e28b506c..20dcdc1bd1 100644
--- a/test/files/run/macro-settings/Impls_Macros_1.scala
+++ b/test/files/run/macro-settings/Impls_Macros_1.scala
@@ -1,7 +1,7 @@
 import scala.reflect.makro.Context
 
 object Impls {
-  def impl(c: Context) = c.reify {
+  def impl(c: Context) = c.universe.reify {
     println(c.literal(c.settings.toString).splice)
   }
 }
diff --git a/test/files/run/macro-sip19-revised/Impls_Macros_1.scala b/test/files/run/macro-sip19-revised/Impls_Macros_1.scala
index 994421808e..013130d181 100644
--- a/test/files/run/macro-sip19-revised/Impls_Macros_1.scala
+++ b/test/files/run/macro-sip19-revised/Impls_Macros_1.scala
@@ -11,7 +11,7 @@ object Macros {
     val fileName = fun.pos.fileInfo.getName
     val line = fun.pos.line
     val charOffset = fun.pos.point
-    c.reify { SourceLocation1(outer.splice, c.literal(fileName).splice, c.literal(line).splice, c.literal(charOffset).splice) }
+    c.universe.reify { SourceLocation1(outer.splice, c.literal(fileName).splice, c.literal(line).splice, c.literal(charOffset).splice) }
   }
 
   implicit def sourceLocation: SourceLocation1 = macro impl
diff --git a/test/files/run/macro-sip19/Impls_Macros_1.scala b/test/files/run/macro-sip19/Impls_Macros_1.scala
index c006ceb691..f6636c298c 100644
--- a/test/files/run/macro-sip19/Impls_Macros_1.scala
+++ b/test/files/run/macro-sip19/Impls_Macros_1.scala
@@ -7,7 +7,7 @@ object Macros {
     val fileName = fun.pos.fileInfo.getName
     val line = fun.pos.line
     val charOffset = fun.pos.point
-    c.reify { SourceLocation(c.literal(fileName).splice, c.literal(line).splice, c.literal(charOffset).splice) }
+    c.universe.reify { SourceLocation(c.literal(fileName).splice, c.literal(line).splice, c.literal(charOffset).splice) }
   }
 
   implicit def sourceLocation: SourceLocation = macro impl
diff --git a/test/files/run/macro-typecheck-macrosdisabled2.check b/test/files/run/macro-typecheck-macrosdisabled2.check
index e440b2c0cb..2160d3800a 100644
--- a/test/files/run/macro-typecheck-macrosdisabled2.check
+++ b/test/files/run/macro-typecheck-macrosdisabled2.check
@@ -15,7 +15,7 @@
       private def applyImpl[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.base.MirrorOf[U]): scala.reflect.base.Universe#Tree = {

         val $u: U = $m$untyped.universe;

         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];

-        $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticModule("scala")), $u.newTermName("Array")), $u.newTermName("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))

+        $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticPackage("scala")), $u.newTermName("Array")), $u.newTermName("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))

       }

     };

     new $treecreator1()

@@ -28,7 +28,7 @@
       def apply[U >: Nothing <: scala.reflect.base.Universe with Singleton]($m$untyped: scala.reflect.base.MirrorOf[U]): U#Type = {

         val $u: U = $m$untyped.universe;

         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];

-        $u.TypeRef.apply($u.ThisType.apply($m.staticModule("scala").asModuleSymbol.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asTypeSymbol.asTypeConstructor))

+        $u.TypeRef.apply($u.ThisType.apply($m.staticPackage("scala").asModuleSymbol.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asTypeSymbol.asTypeConstructor))

       }

     };

     new $typecreator2()

diff --git a/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala b/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala
index b9bb2cfcca..7b921c0e57 100644
--- a/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala
+++ b/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala
@@ -2,12 +2,12 @@ import scala.reflect.runtime.universe._
 import scala.reflect.makro.Context
 
 object Macros {
-  def cons_impl[A: c.AbsTypeTag](c: Context)(x: c.Expr[A], xs: c.Expr[List[A]]): c.Expr[List[A]] = c.reify {
+  def cons_impl[A: c.AbsTypeTag](c: Context)(x: c.Expr[A], xs: c.Expr[List[A]]): c.Expr[List[A]] = c.universe.reify {
     println("A = " + c.literal(implicitly[c.AbsTypeTag[A]].toString).splice)
     x.splice :: xs.splice
   }
 
-  def nil_impl[B: c.AbsTypeTag](c: Context): c.Expr[List[B]] = c.reify {
+  def nil_impl[B: c.AbsTypeTag](c: Context): c.Expr[List[B]] = c.universe.reify {
     println("B = " + c.literal(implicitly[c.AbsTypeTag[B]].toString).splice)
     Nil
   }
diff --git a/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala b/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala
index 9b1dd8e017..fdba40623b 100644
--- a/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala
+++ b/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala
@@ -2,7 +2,7 @@ import scala.reflect.runtime.universe._
 import scala.reflect.makro.Context
 
 object Macros {
-  def impl[T: c.TypeTag](c: Context)(foo: c.Expr[T]): c.Expr[Unit] = c.reify { println(c.literal(implicitly[c.TypeTag[T]].toString).splice) }
+  def impl[T: c.TypeTag](c: Context)(foo: c.Expr[T]): c.Expr[Unit] = c.universe.reify { println(c.literal(implicitly[c.TypeTag[T]].toString).splice) }
 
   def foo[T](foo: T) = macro impl[T]
 }
\ No newline at end of file
diff --git a/test/files/run/reify-staticXXX.check b/test/files/run/reify-staticXXX.check
new file mode 100644
index 0000000000..5762ec47d6
--- /dev/null
+++ b/test/files/run/reify-staticXXX.check
@@ -0,0 +1,24 @@
+object

+object

+class

+class

+object > object

+object > object

+object > class

+object > class

+package > object

+package > object

+package > class

+package > class

+object

+object

+class

+class

+object > object

+object > object

+object > class

+object > class

+package > object

+package > object

+package > class

+package > class

diff --git a/test/files/run/reify-staticXXX.scala b/test/files/run/reify-staticXXX.scala
new file mode 100644
index 0000000000..dc861f843e
--- /dev/null
+++ b/test/files/run/reify-staticXXX.scala
@@ -0,0 +1,56 @@
+import scala.reflect.runtime.universe._
+import scala.tools.reflect.Eval
+
+object B { override def toString = "object" }
+class C { override def toString = "class" }
+
+package foo {
+  object B { override def toString = "package > object" }
+  class C { override def toString = "package > class" }
+}
+
+object foo {
+  object B { override def toString = "object > object" }
+  class C { override def toString = "object > class" }
+}
+
+object packageless {
+  def test = {
+    println(B)
+    println(reify(B).eval)
+    println(new C)
+    println(reify(new C).eval)
+    println(foo.B)
+    println(reify(foo.B).eval)
+    println(new foo.C)
+    println(reify(new foo.C).eval)
+    println(_root_.foo.B)
+    println(reify(_root_.foo.B).eval)
+    println(new _root_.foo.C)
+    println(reify(new _root_.foo.C).eval)
+  }
+}
+
+package packageful {
+  object Test {
+    def test = {
+      println(B)
+      println(reify(B).eval)
+      println(new C)
+      println(reify(new C).eval)
+      println(foo.B)
+      println(reify(foo.B).eval)
+      println(new foo.C)
+      println(reify(new foo.C).eval)
+      println(_root_.foo.B)
+      println(reify(_root_.foo.B).eval)
+      println(new _root_.foo.C)
+      println(reify(new _root_.foo.C).eval)
+    }
+  }
+}
+
+object Test extends App {
+  packageless.test
+  packageful.Test.test
+}
diff --git a/test/files/run/t5713/Impls_Macros_1.scala b/test/files/run/t5713/Impls_Macros_1.scala
index d16299a0c8..c041d36523 100644
--- a/test/files/run/t5713/Impls_Macros_1.scala
+++ b/test/files/run/t5713/Impls_Macros_1.scala
@@ -16,13 +16,13 @@ private object LoggerMacros {
   type LoggerContext = Context { type PrefixType = Logger.type }
 
   def error(c: LoggerContext)(message: c.Expr[String]): c.Expr[Unit] =
-    log(c)(c.reify(Level.Error), message)
+    log(c)(c.universe.reify(Level.Error), message)
 
   private def log(c: LoggerContext)(level: c.Expr[Level.Value], message: c.Expr[String]): c.Expr[Unit] =
 // was:    if (level.splice.id < 4) // TODO Remove hack!
     if (c.eval(level).id < 4) // TODO Remove hack!
-      c.reify(())
+      c.universe.reify(())
     else {
-      c.reify(println(message.splice))
+      c.universe.reify(println(message.splice))
     }
 }
\ No newline at end of file
diff --git a/test/files/run/toolbox_typecheck_macrosdisabled2.check b/test/files/run/toolbox_typecheck_macrosdisabled2.check
index 2e1e2696ab..53041e328d 100644
--- a/test/files/run/toolbox_typecheck_macrosdisabled2.check
+++ b/test/files/run/toolbox_typecheck_macrosdisabled2.check
@@ -15,7 +15,7 @@
       private def applyImpl[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.base.MirrorOf[U]): scala.reflect.base.Universe#Tree = {

         val $u: U = $m$untyped.universe;

         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];

-        $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticModule("scala")), $u.newTermName("Array")), $u.newTermName("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))

+        $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticPackage("scala")), $u.newTermName("Array")), $u.newTermName("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))

       }

     };

     new $treecreator1()

@@ -28,7 +28,7 @@
       def apply[U <: scala.reflect.base.Universe with Singleton]($m$untyped: scala.reflect.base.MirrorOf[U]): U#Type = {

         val $u: U = $m$untyped.universe;

         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];

-        $u.TypeRef.apply($u.ThisType.apply($m.staticModule("scala").asModuleSymbol.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asTypeSymbol.asTypeConstructor))

+        $u.TypeRef.apply($u.ThisType.apply($m.staticPackage("scala").asModuleSymbol.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asTypeSymbol.asTypeConstructor))

       }

     };

     new $typecreator2()

diff --git a/test/pending/run/macro-expand-implicit-macro-defeats-type-inference/Impls_1.scala b/test/pending/run/macro-expand-implicit-macro-defeats-type-inference/Impls_1.scala
index 1740f40daf..599ddf5ed9 100644
--- a/test/pending/run/macro-expand-implicit-macro-defeats-type-inference/Impls_1.scala
+++ b/test/pending/run/macro-expand-implicit-macro-defeats-type-inference/Impls_1.scala
@@ -1,7 +1,7 @@
 import scala.reflect.makro.Context
 
 object Impls {
-  def foo[T: c.TypeTag](c: Context): c.Expr[List[T]] = c.reify {
+  def foo[T: c.TypeTag](c: Context): c.Expr[List[T]] = c.universe.reify {
     println("openImplicits are: " + c.literal(c.openImplicits.toString).splice)
     println("enclosingImplicits are: " + c.literal(c.enclosingImplicits.toString).splice)
     println("typetag is: " + c.literal(c.tag[T].toString).splice)
diff --git a/test/pending/run/macro-reify-array/Macros_1.scala b/test/pending/run/macro-reify-array/Macros_1.scala
index c1bd4187a6..4b4cb05884 100644
--- a/test/pending/run/macro-reify-array/Macros_1.scala
+++ b/test/pending/run/macro-reify-array/Macros_1.scala
@@ -4,7 +4,7 @@ object Macros {
   def foo[T](s: String) = macro Impls.foo[T]
 
   object Impls {
-    def foo[T: c.TypeTag](c: Ctx)(s: c.Expr[T]) = c.reify {
+    def foo[T: c.TypeTag](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
       Array(s.splice)
     }
   }
diff --git a/test/pending/run/macro-reify-tagful-b/Macros_1.scala b/test/pending/run/macro-reify-tagful-b/Macros_1.scala
index 04cf46d3a5..f730bb51f1 100644
--- a/test/pending/run/macro-reify-tagful-b/Macros_1.scala
+++ b/test/pending/run/macro-reify-tagful-b/Macros_1.scala
@@ -4,7 +4,7 @@ object Macros {
   def foo[T](s: T) = macro Impls.foo[List[T]]
 
   object Impls {
-    def foo[T: c.TypeTag](c: Ctx)(s: c.Expr[T]) = c.reify {
+    def foo[T: c.TypeTag](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
       List(s.splice)
     }
   }
diff --git a/test/pending/run/macro-reify-tagless-b/Impls_Macros_1.scala b/test/pending/run/macro-reify-tagless-b/Impls_Macros_1.scala
index 04366353eb..2c5079ea54 100644
--- a/test/pending/run/macro-reify-tagless-b/Impls_Macros_1.scala
+++ b/test/pending/run/macro-reify-tagless-b/Impls_Macros_1.scala
@@ -4,7 +4,7 @@ object Macros {
   def foo[T](s: T) = macro Impls.foo[List[T]]
 
   object Impls {
-    def foo[T](c: Ctx)(s: c.Expr[T]) = c.reify {
+    def foo[T](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
       List(s.splice)
     }
   }
diff --git a/test/pending/run/t5692/Impls_Macros_1.scala b/test/pending/run/t5692/Impls_Macros_1.scala
index f9c1e5f12b..7d0e788bd6 100644
--- a/test/pending/run/t5692/Impls_Macros_1.scala
+++ b/test/pending/run/t5692/Impls_Macros_1.scala
@@ -1,7 +1,7 @@
 import scala.reflect.makro.Context
 
 object Impls {
-  def impl[A](c: reflect.makro.Context) = c.reify(())
+  def impl[A](c: reflect.makro.Context) = c.universe.reify(())
 }
 
 object Macros {