Updated Codification to actually work in presen...

Updated Codification to actually work in presence of functions and
block. Printer has been improved a little too.

3 files changed, 34 insertions, 81 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Codification.scala b/src/compiler/scala/tools/nsc/typechecker/Codification.scala
index 2542f0d9f8..70a4876aee 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Codification.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Codification.scala
@@ -46,6 +46,8 @@ mixin class Codification requires Analyzer {
                          new Reifier(env1, currentOwner).reify(body))
       case This(_) =>
         reflect.This(reify(tree.symbol))
+      case Block(stats, expr) =>
+        reflect.Block(stats.map(reify), reify(expr))
       case _ =>
         throw new TypeError("cannot reify tree: " + tree)
     }
@@ -120,7 +122,11 @@ mixin class Codification requires Analyzer {
       case reflect.Class(_) => "scala.reflect.Class"
       case reflect.Method(_, _) => "scala.reflect.Method"
       case reflect.Field(_, _) => "scala.reflect.Field"
+      case reflect.TypeField(_, _) => "scala.reflect.TypeField"
+      case reflect.LocalValue(_, _, _) => "scala.reflect.LocalValue"
+      case reflect.LocalMethod(_, _, _) => "scala.reflect.LocalMethod"
       case reflect.This(_) => "scala.reflect.This"
+      case reflect.Block(_,_) => "scala.reflect.Block"
       case reflect.NamedType(_) => "scala.reflect.NamedType"
       case reflect.PrefixedType(_, _) => "scala.reflect.PrefixedType"
       case reflect.SingleType(_, _) => "scala.reflect.SingleType"
@@ -148,18 +154,6 @@ mixin class Codification requires Analyzer {
     def inject(value: Any): Tree = value match {
       case FreeValue(tree) =>
         tree
-      case reflect.Function(params, body) =>
-        var env1 = env;
-        val vdefs = for (val param <- params) yield {
-          val lname = newTermName(fresh.newName());
-          env1 = env1.update(param, lname);
-          ValDef(NoMods, lname, injectType("scala.reflect.LocalValue"),
-                 New(injectType("scala.reflect.LocalValue"),
-                     List(List(inject(param.owner), inject(param.name), inject(param.tpe)))))
-        }
-        Block(vdefs, new Injector(env1, fresh).inject(body))
-      case rsym: reflect.LocalSymbol =>
-        Ident(env(rsym))
       case x: String => Literal(Constant(x))
       case x: Boolean => Literal(Constant(x))
       case x: Byte => Literal(Constant(x))
diff --git a/src/library/scala/reflect/Code.scala b/src/library/scala/reflect/Code.scala
index b354bd753f..6632643160 100644
--- a/src/library/scala/reflect/Code.scala
+++ b/src/library/scala/reflect/Code.scala
@@ -19,3 +19,4 @@ case class Apply(fun: Code, args: List[Code]) extends Code;
 case class TypeApply(fun: Code, args: List[Type]) extends Code;
 case class Function(params: List[Symbol], body: Code) extends Code;
 case class This(sym: Symbol) extends Code;
+case class Block(stats: List[Code], expr: Code) extends Code;
\ No newline at end of file
diff --git a/src/library/scala/reflect/Print.scala b/src/library/scala/reflect/Print.scala
index decfe933cc..e6995bc167 100644
--- a/src/library/scala/reflect/Print.scala
+++ b/src/library/scala/reflect/Print.scala
@@ -28,86 +28,44 @@ object Print extends Function1[Any, String] {
     Print(typedCode.code);
 
   def apply (code: Code): String = code match {
-    case reflect.Ident(sym) =>
-      "Ident (" + Print(sym) + ")"
-    case reflect.Select(qual, sym) =>
-      "Select (" + Print(qual) + " from " + Print(sym) + ")"
-    case reflect.Literal(value) =>
-      "Literal (" + value + ")"
-    case reflect.Apply(fun, args) =>
-      ("Apply (" + Print(fun) + " on " +
-       ((args match {
-         case Nil => "nothing "
-         case _ :: _ => args.map(Print).mkString("", ", ", "")
-       }):String) + ")")
-    case reflect.TypeApply(fun, args) =>
-      ("TypeApply (" + Print(fun) + " on " +
-       ((args match {
-         case Nil => "nothing"
-         case _ :: _ => args.map(Print).mkString("", ", ", "")
-       }):String) + ")")
-    case reflect.Function(params, body) =>
-      ("Function (" +
-       ((params match {
-         case Nil => "nothing"
-         case _ :: _ => params.map(Print).mkString("", ", ", "")
-       }):String) + " is " + Print(body) + ")")
-    case reflect.This(sym) =>
-      "This (" + Print(sym) + ")"
-    case _ => "UnknownCode"
+    case reflect.Ident(sym) => Print(sym)
+    case reflect.Select(qual, sym) => "(" + Print(qual) + "." + Print(sym) + ")"
+    case reflect.Literal(value) => "(value: " + value.toString + ")"
+    case reflect.Apply(fun, args) => Print(fun) + args.map(Print).mkString("(", ", ", ")")
+    case reflect.TypeApply(fun, args) => Print(fun) + args.map(Print).mkString("[", ", ", "]")
+    case reflect.Function(params, body) => "(" + params.map(Print).mkString("(", ", ", ")") + " => " + Print(body) + ")"
+    case reflect.This(sym) => "(" + Print(sym) + ".this)"
+    case reflect.Block(stats, expr) => (stats ::: List(expr)).map(Print).mkString("{", ";\n", "}")
+    case _ => "???"
   }
 
   def apply (symbol: Symbol): String = symbol match {
-    case reflect.Class(name) =>
-      "Class (" + name + ")"
-    case reflect.Method(name, datatype) =>
-      "Method (" + name + " of " + Print(datatype) + ")"
-    case reflect.Field(name, datatype) =>
-      "Field (" + name + " of " + Print(datatype) + ")"
-    case reflect.TypeField(name, datatype) =>
-      "TypeField (" + name + " of " + Print(datatype) + ")"
-    case reflect.LocalValue(owner, name, datatype) =>
-      ("LocalValue (" + name + " owned by " + Print(owner) +
-       " of " + Print(datatype) + ")")
-    case reflect.LocalMethod(owner, name, datatype) =>
-      ("LocalMethod (" + name + " owned by " + Print(owner) +
-       " of " + Print(datatype) + ")")
+    case reflect.Class(name) => "(class: " + name + ")"
+    case reflect.Method(name, datatype) => "(method: " + name + ")" //+ ": " + datatype
+    case reflect.Field(name, datatype) => "(field: " + name + ")" //+ ": " + datatype
+    case reflect.TypeField(name, datatype) => "(typefield: " + name + ")" //+ ": " + datatype
+    case reflect.LocalValue(owner, name, datatype) => "(lvalue: " + name + ")" //+ ": " + datatype
+    case reflect.LocalMethod(owner, name, datatype) => "(lmethod: " + name + ")" //+ ": " + datatype
     case reflect.NoSymbol => "NoSymbol"
     case reflect.RootSymbol => "RootSymbol"
-    case _ => "UnknownSymbol"
+    case _ => "???"
   }
 
   def apply (datatype: Type): String = datatype match {
     case reflect.NoPrefix => "NoPrefix"
     case reflect.NoType => "NoType"
-    case reflect.NamedType(name) =>
-      "NamedType (" + name + ")"
-    case reflect.PrefixedType(prefix, symbol) =>
-      "PrefixedType (" + Print(symbol) + " in " + Print(prefix) + ")"
-    case reflect.SingleType(prefix, symbol) =>
-      "SingleType (" + Print(symbol) + " in " + Print(prefix) + ")"
-    case reflect.ThisType(clazz) =>
-      "ThisType (" + Print(clazz) + ")"
-    case reflect.AppliedType(datatype, args) =>
-      ("AppliedType (" + Print(datatype) + " on " +
-       ((args match {
-         case Nil => "nothing"
-         case _ :: _ => args.map(Print).mkString("", ", ", "")
-       }):String) + ")")
-    case reflect.TypeBounds(lo, hi) =>
-      "TypeBounds (" + Print(lo) + " to " + Print(hi) + ")"
-    case reflect.MethodType(formals, resultType) =>
-      ("MethodType (" +
-       ((formals match {
-         case Nil => "nothing"
-         case _ :: _ => formals.map(Print).mkString("", ", ", "")
-       }):String) + " is " + Print(resultType) + ")")
+    case reflect.NamedType(name) => "(named: " + name + ")"
+    case reflect.PrefixedType(prefix, symbol) => "(" + Print(prefix) + "." + Print(symbol) + ")"
+    case reflect.SingleType(prefix, symbol) => "(" + Print(prefix) + "." + Print(symbol) + ")"
+    case reflect.ThisType(clazz) => "(" + Print(clazz) + ".this.type)"
+    case reflect.AppliedType(datatype, args) => Print(datatype) + args.map(Print).mkString("[", ", ", "]")
+    case reflect.TypeBounds(lo, hi) => "[" + Print(lo) + " ... " + Print(hi) + "]"
+    case reflect.MethodType(formals, resultType) => formals.map(Print).mkString("(", ", ", ")") + " => " + Print(resultType)
     case reflect.PolyType(typeParams, typeBounds, resultType) =>
-      ("PolyType (" + (typeParams zip typeBounds).map{
-        case Pair(typeParam, Pair(lo, hi)) =>
-          Print(lo) + " < " + Print(typeParam) + " < " + Print(hi)
-      }.mkString("", ", ", "") + " to " + Print(resultType) + ")")
-    case _ => "UnknownType"
+      (List.map2(typeParams, typeBounds)
+        ((tp, tb) => "[" + Print(tb._1) + " :> " + Print(tp) + " :> " + Print(tb._2) + "]")).
+          mkString("[", ", ", "]") + " -> " + Print(resultType)
+    case _ => "???"
   }
 
 }