evicts calls to reify from our codebase

Until reflection design is stabilized (i.e. 2.10.0 final is released),
it's a good idea to refrain from using reify in our codebase
(either directly in quasiquotes, or indirectly via materialized type tags).

This increases the percentage of changes to reflection that don't require
rebuilding the starr.

The change to build.xml will expose reifications going on during our build
(by printing out their results to the console, so that they bug everyone),
making it easier to spot and fix them.

5 files changed, 44 insertions, 32 deletions

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/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
 }