1 files changed, 47 insertions, 8 deletions
diff --git a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
index 7d404128fb..c578fceb2c 100644
--- a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
+++ b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
@@ -9,20 +9,59 @@ package runtime
 trait Reifiers {
   self: Context =>
 
+  val global: universe.type = universe
   import universe._
   import definitions._
 
-  lazy val reflectMirrorPrefix: Tree = ???
+  lazy val basisUniverse: Tree = gen.mkBasisUniverseRef
 
-  def reifyTree(prefix: Tree, tree: Tree): Tree =
-    scala.reflect.reify.`package`.reifyTree(universe)(callsiteTyper, prefix, tree)
+  lazy val runtimeUniverse: Tree = gen.mkRuntimeUniverseRef
 
-  def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, concrete: Boolean = false): Tree =
-    scala.reflect.reify.`package`.reifyType(universe)(callsiteTyper, prefix, tpe, dontSpliceAtTopLevel, concrete)
+  def reifyTree(universe: Tree, mirror: Tree, tree: Tree): Tree = {
+    val result = scala.reflect.reify.`package`.reifyTree(self.universe)(callsiteTyper, universe, mirror, tree)
+    logFreeVars(enclosingPosition, result)
+    result
+  }
+
+  def reifyType(universe: Tree, mirror: Tree, tpe: Type, concrete: Boolean = false): Tree = {
+    val result = scala.reflect.reify.`package`.reifyType(self.universe)(callsiteTyper, universe, mirror, tpe, concrete)
+    logFreeVars(enclosingPosition, result)
+    result
+  }
 
   def reifyRuntimeClass(tpe: Type, concrete: Boolean = true): Tree =
-    scala.reflect.reify.`package`.reifyRuntimeClass(universe)(callsiteTyper, tpe, concrete)
+    scala.reflect.reify.`package`.reifyRuntimeClass(universe)(callsiteTyper, tpe, concrete = concrete)
+
+  def reifyEnclosingRuntimeClass: Tree =
+    scala.reflect.reify.`package`.reifyEnclosingRuntimeClass(universe)(callsiteTyper)
+
+  def unreifyTree(tree: Tree): Tree = {
+    assert(ExprSplice != NoSymbol)
+    Select(tree, ExprSplice)
+  }
+
+  object utils extends {
+    val global: self.global.type = self.global
+    val typer: global.analyzer.Typer = self.callsiteTyper
+  } with scala.reflect.reify.utils.Utils
+  import utils._
+
+  private def logFreeVars(position: Position, reification: Tree): Unit = {
+    def logFreeVars(symtab: SymbolTable): Unit =
+      // logging free vars only when they are untyped prevents avalanches of duplicate messages
+      symtab.syms map (sym => symtab.symDef(sym)) foreach {
+        case FreeTermDef(_, _, binding, _, origin) if universe.settings.logFreeTerms.value && binding.tpe == null =>
+          reporter.echo(position, "free term: %s %s".format(showRaw(binding), origin))
+        case FreeTypeDef(_, _, binding, _, origin) if universe.settings.logFreeTypes.value && binding.tpe == null =>
+          reporter.echo(position, "free type: %s %s".format(showRaw(binding), origin))
+        case _ =>
+          // do nothing
+      }
 
-  def unreifyTree(tree: Tree): Tree =
-    Select(tree, definitions.ExprSplice)
+    if (universe.settings.logFreeTerms.value || universe.settings.logFreeTypes.value)
+      reification match {
+        case ReifiedTree(_, _, symtab, _, _, _, _) => logFreeVars(symtab)
+        case ReifiedType(_, _, symtab, _, _, _) => logFreeVars(symtab)
+      }
+  }
 }