- Added type and symbol transformation

- Added some missing cases

1 files 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):