- Added automatic generation of Traverser

- Added automatic generation of Transformer

6 files changed, 122 insertions, 611 deletions

diff --git a/sources/meta/GenerateAll.java b/sources/meta/GenerateAll.java
index 761d5cf3c6..1fd2654eeb 100644
--- a/sources/meta/GenerateAll.java
+++ b/sources/meta/GenerateAll.java
@@ -32,6 +32,8 @@ public class GenerateAll extends AbstractMain {
         new meta.scalac.ast.MetaTreeCopier(),
         new meta.scalac.ast.MetaStrictTreeCopier(),
         new meta.scalac.ast.MetaLazyTreeCopier(),
+        new meta.scalac.ast.MetaTraverser(),
+        new meta.scalac.ast.MetaTransformer(),
     };
 
     //########################################################################
diff --git a/sources/scalac/ast/.cvsignore b/sources/scalac/ast/.cvsignore
index c631426a7c..5f102bedbe 100644
--- a/sources/scalac/ast/.cvsignore
+++ b/sources/scalac/ast/.cvsignore
@@ -1,5 +1,7 @@
 DefaultTreeFactory.java
 LazyTreeCopier.java
 StrictTreeCopier.java
+Transformer.java
+Traverser.java
 TreeCopier.java
 TreeFactory.java
diff --git a/sources/scalac/ast/Transformer.java b/sources/scalac/ast/Transformer.java
deleted file mode 100644
index 60c933d833..0000000000
--- a/sources/scalac/ast/Transformer.java
+++ /dev/null
@@ -1,403 +0,0 @@
-/*     ____ ____  ____ ____  ______                                     *\
-**    / __// __ \/ __// __ \/ ____/    SOcos COmpiles Scala             **
-**  __\_ \/ /_/ / /__/ /_/ /\_ \       (c) 2002, LAMP/EPFL              **
-** /_____/\____/\___/\____/____/                                        **
-\*                                                                      */
-
-// $Id$
-
-package scalac.ast;
-
-import java.io.*;
-import java.util.*;
-import scalac.*;
-import scalac.util.*;
-import scalac.symtab.*;
-import Tree.*;
-
-
-/** A default transformer class. This class traverses the abstract
- *  syntax tree but does not do any transformations.
- *
- *  @author     Matthias Zenger
- *  @version    1.0
- */
-public class Transformer {
-
-    /** the global environment
-     */
-    public final Global global;
-
-    /** the tree factory
-     */
-    public final TreeFactory make;
-
-    /** a factory for copying trees; the attribution is preserved or
-     *  translated according to the TreeCopier; trees are only copied
-     *  if new tree introduces changes
-     */
-    public final TreeCopier copy;
-
-    /** a tree generator
-     */
-    public final TreeGen gen;
-
-    /** various constructors
-     */
-    public Transformer(Global global) {
-        this(global, global.make, new LazyTreeCopier(global.make));
-    }
-
-    public Transformer(Global global, TreeFactory make) {
-        this(global, make, new LazyTreeCopier(make));
-    }
-
-    public Transformer(Global global, TreeFactory make, TreeCopier copy) {
-        this.global = global;
-        this.make = make;
-        this.copy = copy;
-        this.gen = global.treeGen;
-    }
-
-    public void apply() {
-        apply(global.units);
-    }
-
-    public void apply(Unit[] units) {
-        for (int i = 0; i < units.length; i++) apply(units[i]);
-    }
-
-    public void apply(Unit unit) {
-	unit.global.log("transforming " + unit);
-        unit.body = transform(unit.body);
-    }
-
-    public Tree[] transform(Tree[] ts) {
-        for (int i = 0; i < ts.length; i++) {
-            Tree t = transform(ts[i]);
-            if (t != ts[i]) {
-                Tree[] res = new Tree[ts.length];
-                System.arraycopy(ts, 0, res, 0, i);
-                res[i] = t;
-                for (int j = i + 1; j < ts.length; j++)
-                    res[j] = transform(ts[j]);
-                return res;
-            }
-        }
-        return ts;
-    }
-
-    public Tree[][] transform(Tree[][] ts) {
-        for (int i = 0; i < ts.length; i++) {
-            Tree[] t = transform(ts[i]);
-            if (t != ts[i]) {
-                Tree[][] res = new Tree[ts.length][];
-                System.arraycopy(ts, 0, res, 0, i);
-                res[i] = t;
-                for (int j = i + 1; j < ts.length; j++)
-                    res[j] = transform(ts[j]);
-                return res;
-            }
-        }
-        return ts;
-    }
-
-    public ValDef[][] transform(ValDef[][] ts) {
-        for (int i = 0; i < ts.length; i++) {
-            ValDef[] t = transform(ts[i]);
-            if (t != ts[i]) {
-                ValDef[][] res = new ValDef[ts.length][];
-                System.arraycopy(ts, 0, res, 0, i);
-                res[i] = t;
-                for (int j = i + 1; j < ts.length; j++)
-                    res[j] = transform(ts[j]);
-                return res;
-            }
-        }
-        return ts;
-    }
-
-    public ValDef[] transform(ValDef[] ts) {
-        for (int i = 0; i < ts.length; i++) {
-            Tree t = transform(ts[i]);
-            if (t != ts[i]) {
-                ValDef[] res = new ValDef[ts.length];
-                System.arraycopy(ts, 0, res, 0, i);
-                res[i] = (ValDef)t;
-                for (int j = i + 1; j < ts.length; j++)
-                    res[j] = (ValDef)transform(ts[j]);
-                return res;
-            }
-        }
-        return ts;
-    }
-
-    public TypeDef[] transform(TypeDef[] ts) {
-        for (int i = 0; i < ts.length; i++) {
-            Tree t = transform(ts[i]);
-            if (t != ts[i]) {
-                TypeDef[] res = new TypeDef[ts.length];
-                System.arraycopy(ts, 0, res, 0, i);
-                res[i] = (TypeDef)t;
-                for (int j = i + 1; j < ts.length; j++)
-                    res[j] = (TypeDef)transform(ts[j]);
-                return res;
-            }
-        }
-        return ts;
-    }
-
-    public CaseDef[] transform(CaseDef[] ts) {
-        for (int i = 0; i < ts.length; i++) {
-            Tree t = transform(ts[i]);
-            if (t != ts[i]) {
-                CaseDef[] res = new CaseDef[ts.length];
-                System.arraycopy(ts, 0, res, 0, i);
-                res[i] = (CaseDef)t;
-                for (int j = i + 1; j < ts.length; j++)
-                    res[j] = (CaseDef)transform(ts[j]);
-                return res;
-            }
-        }
-        return ts;
-    }
-
-    public Template transform(Template tree) {
-        return (Template)transform((Tree)tree);
-    }
-
-    public Tree transform(Tree tree) {
-        if (tree == null)
-            return null;
-        switch (tree) {
-	case ClassDef(int mods,
-		      Name name,
-		      TypeDef[] tparams,
-		      ValDef[][] vparams,
-		      Tree tpe,
-		      Template impl):
-	    return copy.ClassDef(tree,
-				 mods,
-				 name,
-				 transform(tparams),
-				 transform(vparams),
-				 transform(tpe),
-				 transform(impl));
-	case PackageDef(Tree packaged, Template impl):
-	    return copy.PackageDef(tree,
-				   transform(packaged),
-				   transform(impl));
-	case ModuleDef(int mods,
-		       Name name,
-		       Tree tpe,
-		       Template impl):
-	    return copy.ModuleDef(tree,
-				  mods,
-				  name,
-				  transform(tpe),
-				  transform(impl));
-	case ValDef(int mods,
-		    Name name,
-		    Tree tpe,
-		    Tree rhs):
-	    return copy.ValDef(tree,
-			       mods,
-			       name,
-			       transform(tpe),
-			       transform(rhs));
-	case PatDef(int mods,
-		    Tree pat,
-		    Tree rhs):
-	    return copy.PatDef(tree,
-			       mods,
-			       transform(pat),
-			       transform(rhs));
-	case DefDef(int mods,
-		    Name name,
-		    TypeDef[] tparams,
-		    ValDef[][] vparams,
-		    Tree tpe,
-		    Tree rhs):
-	    return copy.DefDef(tree,
-			       mods,
-			       name,
-			       transform(tparams),
-			       transform(vparams),
-			       transform(tpe),
-			       transform(rhs));
-	case TypeDef(int mods,
-		     Name name,
-		     Tree rhs):
-	    return copy.TypeDef(tree,
-				mods,
-				name,
-				transform(rhs));
-	case Import(Tree expr, Name[] selectors):
-	    return copy.Import(tree,
-			       transform(expr),
-			       selectors);
-	case CaseDef(Tree pat, Tree guard, Tree body):
-	    return copy.CaseDef(tree,
-				transform(pat),
-				transform(guard),
-				transform(body));
-	case Template(Tree[] parents, Tree[] body):
-	    return copy.Template(tree,
-				 transform(parents),
-				 transform(body));
-	case LabelDef(Tree[] params,Tree rhs):
-	    return copy.LabelDef(tree,
-				 transform(params),
-				 transform(rhs));
-	case Block(Tree[] stats):
-	    return copy.Block(tree,
-			      transform(stats));
-	case Tuple(Tree[] trees):
-	    return copy.Tuple(tree,
-			      transform(trees));
-	case Visitor(CaseDef[] cases):
-	    return copy.Visitor(tree,
-				transform(cases));
-	case Function(ValDef[] vparams, Tree body):
-	    return copy.Function(tree,
-				 transform(vparams),
-				 transform(body));
-	case Assign(Tree lhs, Tree rhs):
-	    return copy.Assign(tree,
-			       transform(lhs),
-			       transform(rhs));
-	case If(Tree cond, Tree thenp, Tree elsep):
-	    return copy.If(tree,
-			   transform(cond),
-			   transform(thenp),
-			   transform(elsep));
-	case New(Template templ):
-	    return copy.New(tree,
-			    transform(templ));
-	case Typed(Tree expr, Tree tpe):
-	    return copy.Typed(tree,
-			      transform(expr),
-			      transform(tpe));
-	case TypeApply(Tree fun, Tree[] args):
-	    return copy.TypeApply(tree,
-				  transform(fun),
-				  transform(args));
-	case Apply(Tree fun, Tree[] args):
-	    return copy.Apply(tree,
-			      transform(fun),
-			      transform(args));
-	case Super(Tree tpe):
-	    return copy.Super(tree,
-			      transform(tpe));
-	case This(Tree qualifier):
-	    return copy.This(tree,
-			     transform(qualifier));
-	case Select(Tree qualifier, Name selector):
-	    return copy.Select(tree,
-			       transform(qualifier),
-			       selector);
-	case Ident(Name name):
-	    return copy.Ident(tree, name);
-	case Literal(Object value):
-	    return copy.Literal(tree, value);
-	case TypeTerm():
-	    return copy.TypeTerm(tree);
-	case SingletonType(Tree ref):
-	    return copy.SingletonType(tree,
-				      transform(ref));
-	case SelectFromType(Tree qualifier, Name selector):
-	    return copy.SelectFromType(tree,
-				       transform(qualifier),
-				       selector);
-	case FunType(Tree[] argtpes, Tree restpe):
-	    return copy.FunType(tree,
-				transform(argtpes),
-				transform(restpe));
-	case CompoundType(Tree[] parents, Tree[] refinements):
-	    return copy.CompoundType(tree,
-				     transform(parents),
-				     transform(refinements));
-	case AppliedType(Tree tpe, Tree[] args):
-	    return copy.AppliedType(tree,
-				    transform(tpe),
-				    transform(args));
-	case CovariantType(Tree tpe):
-	    return copy.CovariantType(tree,
-				      transform(tpe));
-	default:
-	    return tree;
-        }
-    }
-    /* a full pattern-matching statement:
-
-        switch (tree) {
-        case PackageDef(Tree packaged, Template impl):
-
-	case ClassDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams,
-	              Template impl):
-
-	case ModuleDef(int mods, Name name, Tree tpe, Template impl):
-
-	case ValDef(int mods, Name name, Tree tpe, Tree rhs):
-
-	case PatDef(int mods, Tree pat, Tree rhs):
-
-	case DefDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams,
-	            Tree tpe, Tree rhs):
-
-	case TypeDef(int mods, Name name, Tree rhs):
-
-	case Import(Tree expr):
-
-	case CaseDef(Tree pat, Tree guard, Tree body):
-
-	case Template(Tree[] baseClasses, Tree[] body):
-
-	case LabelDef(Tree[] params,Tree rhs):
-
-	case Block(Tree[] stats):
-
-	case Tuple(Tree[] trees):
-
-	case Visitor(CaseDef[] cases):
-
-	case Function(ValDef[] vparams, Tree body):
-
-	case Assign(Tree lhs, Tree rhs):
-
-	case If(Tree cond, Tree thenp, Tree elsep):
-
-	case New(Template templ):
-
-	case Typed(Tree expr, Tree tpe):
-
-	case TypeApply(Tree fun, Tree[] args):
-
-	case Apply(Tree fun, Tree[] args):
-
-	case Super(Tree tpe):
-
-	case Select(Tree qualifier, Name selector):
-
-	case Ident(Name name):
-
-	case Literal(int kind, Object value):
-
-	case TypeTerm():
-
-	case SingletonType(Tree ref):
-
-	case SelectFromType(Tree qualifier, Name selector):
-
-	case FunType(Tree argtpe, Tree restpe):
-
-	case CompoundType(Tree[] baseTypes, Tree[] refinements):
-
-	case AppliedType(Tree tpe, Tree[] args):
-
-	default:
-	    return tree;
-        }
-    */
-
-}
diff --git a/sources/scalac/ast/Transformer.java.tmpl b/sources/scalac/ast/Transformer.java.tmpl
new file mode 100644
index 0000000000..9e83e34b18
--- /dev/null
+++ b/sources/scalac/ast/Transformer.java.tmpl
@@ -0,0 +1,81 @@
+/*     ____ ____  ____ ____  ______                                     *\
+**    / __// __ \/ __// __ \/ ____/    SOcos COmpiles Scala             **
+**  __\_ \/ /_/ / /__/ /_/ /\_ \       (c) 2002, LAMP/EPFL              **
+** /_____/\____/\___/\____/____/                                        **
+\*                                                                      */
+
+// $Id$
+
+package scalac.ast;
+
+import scalac.Global;
+import scalac.Unit;
+{#Imports#}
+
+/**
+ * A default transformer class. This class traverses the abstract
+ * syntax tree but does not do any transformations.
+ */
+public class Transformer {
+
+    //########################################################################
+    // Public Fields
+
+    /** The global environment */
+    public final Global global;
+
+    /** The tree factory */
+    public final TreeFactory make;
+
+    /** The tree copier */
+    public final TreeCopier copy;
+
+    /** A tree generator */
+    public final TreeGen gen;
+
+    //########################################################################
+    // Public Constructors
+
+    public Transformer(Global global) {
+        this(global, global.make);
+    }
+
+    public Transformer(Global global, TreeFactory make) {
+        this(global, make, new LazyTreeCopier(make));
+    }
+
+    public Transformer(Global global, TreeFactory make, TreeCopier  copy) {
+        this.global = global;
+        this.make = make;
+        this.copy = copy;
+        this.gen = global.treeGen;
+    }
+
+    //########################################################################
+    // Public Methods
+
+    public void apply() {
+        apply(global.units);
+    }
+
+    public void apply(Unit[] units) {
+        for (int i = 0; i < units.length; i++) apply(units[i]);
+    }
+
+    public void apply(Unit unit) {
+        unit.global.log("transforming " + unit);
+        unit.body = transform(unit.body);
+    }
+
+    public Tree transform(Tree tree) {
+        {#TreeSwitch#}
+    }
+
+    public Template transform(Template tree) {
+        return (Template)transform((Tree)tree);
+    }
+
+    {#TransformArrays#}
+
+    //########################################################################
+}
diff --git a/sources/scalac/ast/Traverser.java b/sources/scalac/ast/Traverser.java
deleted file mode 100644
index d4eeaf743f..0000000000
--- a/sources/scalac/ast/Traverser.java
+++ /dev/null
@@ -1,208 +0,0 @@
-/*     ____ ____  ____ ____  ______                                     *\
-**    / __// __ \/ __// __ \/ ____/    SOcos COmpiles Scala             **
-**  __\_ \/ /_/ / /__/ /_/ /\_ \       (c) 2002, LAMP/EPFL              **
-** /_____/\____/\___/\____/____/                                        **
-**                                                                      **
-\*                                                                      */
-
-// $Id$
-
-package scalac.ast;
-
-import scalac.Unit;
-import scalac.ast.Tree.*;
-import scalac.util.Name;
-import scalac.util.Debug;
-
-
-/** Class to traverse a tree without modifying it.
- *
- *  @author     Michel Schinz
- */
-
-public class Traverser {
-
-    public void traverse(Unit unit) {
-        traverse(unit.body);
-    }
-
-    public void traverse(Tree tree) {
-        switch (tree) {
-        case Bad():
-        case Empty:
-        case Ident(_):
-        case Literal(_):
-            return;
-
-        case ClassDef(int mods,
-                      Name name,
-                      TypeDef[] tparams,
-                      ValDef[][] vparams,
-		      Tree tpe,
-                      Template impl):
-            traverse(tparams);
-            traverse(vparams);
-	    traverse(tpe);
-            traverse(impl);
-            return;
-
-        case PackageDef(Tree packaged, Template impl) :
-            traverse(packaged);
-            traverse(impl);
-            return;
-
-        case ModuleDef(int mods, Name name, Tree tpe, Template impl):
-            traverse(tpe);
-            traverse(impl);
-            return;
-
-        case ValDef(int mods, Name name, Tree tpe, Tree rhs):
-            traverse(tpe);
-            traverse(rhs);
-            return;
-
-        case PatDef(int mods, Tree pat, Tree rhs):
-            traverse(pat);
-            traverse(rhs);
-            return;
-
-        case DefDef(int mods,
-                    Name name,
-                    TypeDef[] tparams,
-                    ValDef[][] vparams,
-                    Tree tpe,
-                    Tree rhs):
-            traverse(tparams);
-            traverse(vparams);
-            traverse(tpe);
-            traverse(rhs);
-            return;
-
-        case TypeDef(int mods, Name name, Tree rhs):
-            traverse(rhs);
-            return;
-
-        case Import(Tree expr, Name[] selectors):
-            traverse(expr);
-            return;
-
-        case CaseDef(Tree pat, Tree guard, Tree body):
-            traverse(pat);
-            traverse(guard);
-            traverse(body);
-            return;
-
-        case Template(Tree[] baseClasses, Tree[] body):
-            traverse(baseClasses);
-            traverse(body);
-            return;
-
-	case LabelDef(Tree[] params,Tree rhs):
-	    traverse(params);
-	    traverse(rhs);
-	    return;
-
-        case Block(Tree[] stats):
-            traverse(stats);
-            return;
-
-        case Tuple(Tree[] trees):
-            traverse(trees);
-            return;
-
-        case Visitor(CaseDef[] cases):
-            traverse(cases);
-            return;
-
-        case Function(ValDef[] vparams, Tree body):
-            traverse(vparams);
-            traverse(body);
-            return;
-
-        case Assign(Tree lhs, Tree rhs):
-            traverse(lhs);
-            traverse(rhs);
-            return;
-
-        case If(Tree cond, Tree thenp, Tree elsep):
-            traverse(cond);
-            traverse(thenp);
-            traverse(elsep);
-            return;
-
-        case New(Template templ):
-            traverse(templ);
-            return;
-
-        case Typed(Tree expr, Tree tpe):
-            traverse(expr);
-            traverse(tpe);
-            return;
-
-        case TypeApply(Tree fun, Tree[] tparams):
-            traverse(fun);
-            traverse(tparams);
-            return;
-
-        case Apply(Tree fun, Tree[] vparam):
-            traverse(fun);
-            traverse(vparam);
-            return;
-
-        case Super(Tree tpe):
-            traverse(tpe);
-            return;
-
-        case This(Tree qualifier):
-            traverse(qualifier);
-            return;
-
-        case Select(Tree qualifier, Name selector):
-            traverse(qualifier);
-            return;
-
-	case TypeTerm():
-	    return;
-
-	case SingletonType(Tree ref):
-	    traverse(ref);
-	    return;
-
-	case SelectFromType(Tree qualifier, Name selector):
-	    traverse(qualifier);
-	    return;
-
-        case FunType(Tree[] argtpes, Tree restpe):
-            traverse(argtpes);
-            traverse(restpe);
-            return;
-
-        case CompoundType(Tree[] baseTypes, Tree[] refinements):
-            traverse(baseTypes);
-            traverse(refinements);
-            return;
-
-        case AppliedType(Tree tpe, Tree[] args):
-            traverse(tpe);
-            traverse(args);
-            return;
-
-        case CovariantType(Tree tpe):
-            traverse(tpe);
-            return;
-
-        default:
-            throw Debug.abort("unknown node", tree);
-        }
-    }
-
-    public void traverse(Tree[] array) {
-        for (int i = 0; i < array.length; ++i)
-            traverse(array[i]);
-    }
-
-    public void traverse(Tree[][] array) {
-        for (int i = 0; i < array.length; ++i)
-            traverse(array[i]);
-    }
-}
diff --git a/sources/scalac/ast/Traverser.java.tmpl b/sources/scalac/ast/Traverser.java.tmpl
new file mode 100644
index 0000000000..f46d40b09b
--- /dev/null
+++ b/sources/scalac/ast/Traverser.java.tmpl
@@ -0,0 +1,37 @@
+/*     ____ ____  ____ ____  ______                                     *\
+**    / __// __ \/ __// __ \/ ____/    SOcos COmpiles Scala             **
+**  __\_ \/ /_/ / /__/ /_/ /\_ \       (c) 2002, LAMP/EPFL              **
+** /_____/\____/\___/\____/____/                                        **
+\*                                                                      */
+
+// $Id$
+
+package scalac.ast;
+
+import scalac.Unit;
+{#Imports#}
+
+/** Class to traverse a tree without modifying it. */
+public class Traverser {
+
+    //########################################################################
+    // Public Methods
+
+    public void traverse(Unit unit) {
+        traverse(unit.body);
+    }
+
+    public void traverse(Tree tree) {
+        {#TreeSwitch#}
+    }
+
+    public void traverse(Tree[] trees) {
+        for (int i = 0; i < trees.length; i++) traverse(trees[i]);
+    }
+
+    public void traverse(Tree[][] trees) {
+        for (int i = 0; i < trees.length; i++) traverse(trees[i]);
+    }
+
+    //########################################################################
+}