From f936b14dd7c114a40890d6164feef2c4c4455842 Mon Sep 17 00:00:00 2001 From: paltherr Date: Tue, 25 Nov 2003 09:17:47 +0000 Subject: - Added type and symbol transformation - Added some missing cases --- sources/scalac/ast/Transformer.java.tmpl | 91 +++++++++++++++++++++++++------- 1 file changed, 72 insertions(+), 19 deletions(-) diff --git a/sources/scalac/ast/Transformer.java.tmpl b/sources/scalac/ast/Transformer.java.tmpl index b54d27e8ad..bf97e2cbb1 100644 --- a/sources/scalac/ast/Transformer.java.tmpl +++ b/sources/scalac/ast/Transformer.java.tmpl @@ -10,6 +10,7 @@ package scalac.ast; import scalac.Global; import scalac.Unit; +import scalac.symtab.Type; {#Imports#} /** @@ -85,16 +86,25 @@ public class GenTransformer { /** The global environment */ public final Global global; + /** The type map */ + public final Type.Map map; + /** A tree generator */ public final TreeGen gen; //######################################################################## // Public Constructors - /** Initializes this instance. */ + /** Initializes this instance with an identity type map. */ public GenTransformer(Global global) { + this(global, Type.IdMap); + } + + /** Initializes this instance with given type map. */ + public GenTransformer(Global global, Type.Map map) { this.global = global; this.gen = global.treeGen; + this.map = map; } //######################################################################## @@ -111,6 +121,30 @@ public class GenTransformer { unit.body = transform(unit.body); } + /** Transforms the given symbol. */ + public Symbol getSymbolFor(Tree tree) { + return tree.symbol(); + } + + /** Transforms the given types. */ + public Type[] transform(Type[] types) { + for (int i = 0; i < types.length; i++) { + Type type = transform(types[i]); + if (type == types[i]) continue; + Type[] clones = new Type[types.length]; + for (int j = 0; j < i; j++) clones[j] = types[j]; + clones[i] = type; + for (; i < types.length; i++) clones[i] = transform(types[i]); + return clones; + } + return types; + } + + /** Transforms the given type. */ + public Type transform(Type type) { + return map.apply(type); + } + /** Transforms the given tree. */ public Tree transform(Tree tree) { switch (tree) { @@ -121,38 +155,51 @@ public class GenTransformer { return tree; case ClassDef(_, _, _, _, _, Template impl): - Symbol clasz = tree.symbol(); + Symbol symbol = getSymbolFor(tree); + Symbol impl_symbol = getSymbolFor(impl); Tree[] parents = transform(impl.parents); Tree[] body = transform(impl.body); - return gen.ClassDef(clasz, parents, impl.symbol(), body); + return gen.ClassDef(symbol, parents, impl_symbol, body); case PackageDef(Tree packaged, Template(Tree[] parents, Tree[] body)): + Symbol symbol = getSymbolFor(packaged); assert parents.length == 0: tree; - return gen.PackageDef(packaged.symbol(), transform(body)); + return gen.PackageDef(symbol, transform(body)); // case ModuleDef(_, _, _, Template impl): case ValDef(_, _, _, Tree rhs): - return gen.ValDef(tree.symbol(), transform(rhs)); + Symbol symbol = getSymbolFor(tree); + return gen.ValDef(symbol, transform(rhs)); // case PatDef(int mods, Tree pat, Tree rhs): case DefDef(_, _, _, _, _, Tree rhs): - return gen.DefDef(tree.symbol(), transform(rhs)); + Symbol symbol = getSymbolFor(tree); + return gen.DefDef(symbol, transform(rhs)); case AbsTypeDef(_, _, _, _): - return gen.AbsTypeDef(tree.symbol()); + Symbol symbol = getSymbolFor(tree); + return gen.AbsTypeDef(symbol); case AliasTypeDef(_, _, _, _): - return gen.AliasTypeDef(tree.symbol()); + Symbol symbol = getSymbolFor(tree); + return gen.AliasTypeDef(symbol); + + case Import(Tree expr, Name[] selectors): + return gen.Import(tree.pos, transform(expr), selectors); + + case CaseDef(Tree pat, Tree guard, Tree body): + pat = transform(pat); + guard = transform(guard); + body = transform(body); + return gen.CaseDef(pat, guard, body); - // case Import(Tree expr, Name[] selectors): - // case CaseDef(Tree pat, Tree guard, Tree body): // case Template(Tree[] parents, Tree[] body): case LabelDef(_, Ident[] params, Tree rhs): - Symbol label = tree.symbol(); - return gen.LabelDef(label, Tree.symbolOf(params), transform(rhs)); + Symbol symbol = getSymbolFor(tree); + return gen.LabelDef(symbol, transform(params), transform(rhs)); case Block(Tree[] stats): return gen.Block(tree.pos, transform(stats)); @@ -179,7 +226,8 @@ public class GenTransformer { return gen.Switch(tree.pos, test, tags, bodies, otherwise); case Return(Tree expr): - return gen.Return(tree.pos, tree.symbol(), transform(expr)); + Symbol symbol = getSymbolFor(tree); + return gen.Return(tree.pos, symbol, transform(expr)); // case Throw(Tree expr): @@ -187,7 +235,8 @@ public class GenTransformer { assert base.length == 1 && body.length == 0: tree; return gen.New(tree.pos, transform(base[0])); - // case Typed(Tree expr, Tree tpe): + case Typed(Tree expr, Tree tpe): + return gen.Typed(tree.pos, transform(expr), transform(tpe)); case TypeApply(Tree fun, Tree[] args): return gen.TypeApply(transform(fun), transform(args)); @@ -196,22 +245,26 @@ public class GenTransformer { return gen.Apply(transform(fun), transform(args)); case Super(_, _): - return gen.Super(tree.pos, tree.symbol()); + Symbol symbol = getSymbolFor(tree); + return gen.Super(tree.pos, symbol); case This(_): - return gen.This(tree.pos, tree.symbol()); + Symbol symbol = getSymbolFor(tree); + return gen.This(tree.pos, symbol); case Select(Tree qualifier, _): - return gen.Select(tree.pos, transform(qualifier), tree.symbol()); + Symbol symbol = getSymbolFor(tree); + return gen.Select(tree.pos, transform(qualifier), symbol); case Ident(_): - return gen.Ident(tree.pos, tree.symbol()); + Symbol symbol = getSymbolFor(tree); + return gen.Ident(tree.pos, symbol); case Literal(Object value): return gen.mkLit(tree.pos, value); case TypeTerm(): - return tree; + return gen.mkType(tree.pos, transform(tree.type())); // case SingletonType(Tree ref): // case SelectFromType(Tree qualifier, Name selector): -- cgit v1.2.3