SI-6392 wraps non-terms before typecheck/eval

Wrap non-term arguments of typecheck and eval, so that toolboxes
can work with full-fledged files (except for package declarations).

Author: xeno-by

src/compiler/scala/tools/reflect/ToolBoxFactory.scala

@@ -70,6 +70,14 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
         }
       }
 
+      def wrapIntoTerm(tree: Tree): Tree =
+        if (!tree.isTerm) Block(List(tree), Literal(Constant(()))) else tree
+
+      def unwrapFromTerm(tree: Tree): Tree = tree match {
+        case Block(List(tree), Literal(Constant(()))) => tree
+        case tree => tree
+      }
+
       def extractFreeTerms(expr0: Tree, wrapFreeTermRefs: Boolean): (Tree, scala.collection.mutable.LinkedHashMap[FreeTermSymbol, TermName]) = {
         val freeTerms = expr0.freeTerms
         val freeTermNames = scala.collection.mutable.LinkedHashMap[FreeTermSymbol, TermName]()
@@ -102,7 +110,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
         // need to wrap the expr, because otherwise you won't be able to typecheck macros against something that contains free vars
         var (expr, freeTerms) = extractFreeTerms(expr0, wrapFreeTermRefs = false)
         val dummies = freeTerms.map{ case (freeTerm, name) => ValDef(NoMods, name, TypeTree(freeTerm.info), Select(Ident(PredefModule), newTermName("$qmark$qmark$qmark"))) }.toList
-        expr = Block(dummies, expr)
+        expr = Block(dummies, wrapIntoTerm(expr))
 
         // [Eugene] how can we implement that?
         // !!! Why is this is in the empty package? If it's only to make
@@ -137,6 +145,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
             }
         }.transform(unwrapped)
         new TreeTypeSubstituter(dummies1 map (_.symbol), dummies1 map (dummy => SingleType(NoPrefix, invertedIndex(dummy.symbol.name)))).traverse(unwrapped)
+        unwrapped = if (expr0.isTerm) unwrapped else unwrapFromTerm(unwrapped)
         unwrapped
       }
 
@@ -170,7 +179,9 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
             }
           })
 
-      def compile(expr: Tree): () => Any = {
+      def compile(expr0: Tree): () => Any = {
+        val expr = wrapIntoTerm(expr0)
+
         val freeTerms = expr.freeTerms // need to calculate them here, because later on they will be erased
         val thunks = freeTerms map (fte => () => fte.value) // need to be lazy in order not to distort evaluation order
         verify(expr)

test/files/run/t6392a.check

@@ -0,0 +1 @@
+()

test/files/run/t6392a.scala

@@ -0,0 +1,9 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.tools.reflect.ToolBox
+
+object Test extends App {
+  val tb = cm.mkToolBox()
+  val c = tb.parse("object C")
+  println(tb.eval(c))
+}

test/files/run/t6392b.check

@@ -0,0 +1 @@
+ModuleDef(Modifiers(), newTermName("C"), Template(List(Select(Ident(scala#PK), newTypeName("AnyRef")#TPE)), emptyValDef, List(DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(newTypeName("C")), tpnme.EMPTY), nme.CONSTRUCTOR#PCTOR), List())), Literal(Constant(())))))))

test/files/run/t6392b.scala

@@ -0,0 +1,9 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.tools.reflect.ToolBox
+
+object Test extends App {
+  val tb = cm.mkToolBox()
+  val c = tb.parse("object C")
+  println(showRaw(tb.typeCheck(c), printKinds = true))
+}