From d8d15e97004f3eb52072286bfe727c31ac995a40 Mon Sep 17 00:00:00 2001 From: Gilles Dubochet Date: Fri, 13 Jan 2006 18:15:38 +0000 Subject: 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. --- .../scala/tools/nsc/typechecker/Codification.scala | 18 ++-- src/library/scala/reflect/Code.scala | 1 + src/library/scala/reflect/Print.scala | 96 ++++++---------------- 3 files changed, 34 insertions(+), 81 deletions(-) (limited to 'src') 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 _ => "???" } } -- cgit v1.2.3