summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorpaltherr <paltherr@epfl.ch>2003-04-30 07:44:06 +0000
committerpaltherr <paltherr@epfl.ch>2003-04-30 07:44:06 +0000
commitfa72586d0b7c8fef92643d1d1402c8d94bea9c3d (patch)
treeb6deef5e7f28373abe0f5157f55fc27d39fd7a0e
parent4d1dfaffedbe38038fcfe2fc3af01f1c949a53fe (diff)
downloadscala-fa72586d0b7c8fef92643d1d1402c8d94bea9c3d.tar.gz
scala-fa72586d0b7c8fef92643d1d1402c8d94bea9c3d.tar.bz2
scala-fa72586d0b7c8fef92643d1d1402c8d94bea9c3d.zip
- Added methods which take a symbol in TreeFact...
- Added methods which take a symbol in TreeFactories and TreeCopiers.
Diffstat
-rw-r--r--sources/meta/scalac/ast/AbstractTreeCaseExpander.java4
-rw-r--r--sources/meta/scalac/ast/AbstractTreeExpander.java11
-rw-r--r--sources/meta/scalac/ast/AbstractTreeMethodExpander.java13
-rw-r--r--sources/meta/scalac/ast/MetaDefaultTreeFactory.java7
-rw-r--r--sources/meta/scalac/ast/MetaLazyTreeCopier.java40
-rw-r--r--sources/meta/scalac/ast/MetaStrictTreeCopier.java26
-rw-r--r--sources/meta/scalac/ast/MetaTransformer.java62
-rw-r--r--sources/meta/scalac/ast/MetaTraverser.java19
-rw-r--r--sources/meta/scalac/ast/MetaTree.java129
-rw-r--r--sources/meta/scalac/ast/MetaTreeCopier.java8
-rw-r--r--sources/meta/scalac/ast/MetaTreeFactory.java5
-rw-r--r--sources/meta/scalac/ast/Tree.java128
-rw-r--r--sources/meta/scalac/ast/TreeField.java23
-rw-r--r--sources/meta/scalac/ast/TreeFieldLink.java6
-rw-r--r--sources/meta/scalac/ast/TreeNode.java191
-rw-r--r--sources/meta/scalac/ast/TreeSymbol.java5
-rw-r--r--sources/meta/scalac/ast/TreeType.java15
-rw-r--r--sources/scalac/ast/SubstTransformer.java23
-rw-r--r--sources/scalac/ast/Traverser.java.tmpl8
-rw-r--r--sources/scalac/transformer/AddAccessors.java17
-rw-r--r--sources/scalac/transformer/AddInterfaces.java24
-rw-r--r--sources/scalac/transformer/Erasure.java21
-rw-r--r--sources/scalac/transformer/ExpandMixins.java20
-rw-r--r--sources/scalac/transformer/ExplicitOuterClasses.java17
-rw-r--r--sources/scalac/transformer/LambdaLift.java33
-rw-r--r--sources/scalac/transformer/OwnerTransformer.java52
-rw-r--r--sources/scalac/transformer/UnCurry.java13
-rw-r--r--sources/scalac/typechecker/Analyzer.java42
-rw-r--r--sources/scalac/typechecker/DeSugarize.java4
-rw-r--r--sources/scalac/typechecker/RefCheck.java12
30 files changed, 572 insertions, 406 deletions
diff --git a/sources/meta/scalac/ast/AbstractTreeCaseExpander.java b/sources/meta/scalac/ast/AbstractTreeCaseExpander.java
index aa026ed3cf..c7e023c16f 100644
--- a/sources/meta/scalac/ast/AbstractTreeCaseExpander.java
+++ b/sources/meta/scalac/ast/AbstractTreeCaseExpander.java
@@ -15,7 +15,7 @@ public abstract class AbstractTreeCaseExpander extends AbstractTreeExpander {
// Public Constructors
public AbstractTreeCaseExpander() {
- writer.importType(tree.t_Debug);
+ writer.importType(t_Debug);
}
//########################################################################
@@ -27,7 +27,7 @@ public abstract class AbstractTreeCaseExpander extends AbstractTreeExpander {
printTreeCases();
writer.println("default:");
writer.indent();
- writer.print("throw ").print(tree.t_Debug).
+ writer.print("throw ").print(t_Debug).
println(".abort(\"unknown tree\", tree);");
writer.undent();
writer.println("}");
diff --git a/sources/meta/scalac/ast/AbstractTreeExpander.java b/sources/meta/scalac/ast/AbstractTreeExpander.java
index e7a162d7fe..503a9651a2 100644
--- a/sources/meta/scalac/ast/AbstractTreeExpander.java
+++ b/sources/meta/scalac/ast/AbstractTreeExpander.java
@@ -8,6 +8,7 @@
package meta.scalac.ast;
+import meta.java.Type;
import meta.java.AbstractJavaExpander;
/** A base class for expanders that handle tree nodes. */
@@ -16,18 +17,24 @@ public abstract class AbstractTreeExpander extends AbstractJavaExpander {
//########################################################################
// Public Fields
+ public final Type t_Debug;
public final Tree tree;
//########################################################################
// Public Constructors
public AbstractTreeExpander() {
+ this.t_Debug = TreeType.Reference("scalac.util", "Debug");
this.tree = new Tree();
- writer.importFrom(tree.t_Tree);
- for (int i = 0; i < tree.nodes.length; i++)
+ writer.importFrom(t_Debug);
+ writer.importFrom(tree.getType(0));
+ for (int i = 0; i < tree.nodes.length; i++) {
if (tree.nodes[i].fields != null)
for (int j = 0; j < tree.nodes[i].fields.length; j++)
writer.importType(tree.nodes[i].fields[j].type);
+ if (tree.nodes[i].hasSymbol())
+ writer.importType(tree.nodes[i].getSymbol().type);
+ }
}
//########################################################################
diff --git a/sources/meta/scalac/ast/AbstractTreeMethodExpander.java b/sources/meta/scalac/ast/AbstractTreeMethodExpander.java
index 78000ccb94..7444759111 100644
--- a/sources/meta/scalac/ast/AbstractTreeMethodExpander.java
+++ b/sources/meta/scalac/ast/AbstractTreeMethodExpander.java
@@ -16,17 +16,16 @@ public abstract class AbstractTreeMethodExpander extends AbstractTreeExpander {
public void printTreeMethods() {
for (int i = 0; i < tree.nodes.length; i++) {
- if (tree.nodes[i].fields != null) printTreeMethod(tree.nodes[i]);
+ if (tree.nodes[i].fields != null) {
+ printTreeMethod(tree.nodes[i], false);
+ if (tree.nodes[i].hasSymbol())
+ printTreeMethod(tree.nodes[i], true);
+ }
writer.println();
}
}
- public abstract void printTreeMethod(TreeNode node);
-
- public void printTreeMethodHeader(TreeNode node, String prefix) {
- writer.print("public " + node.name + " " + node.name + "(");
- node.printParams(writer, prefix).print(")");
- }
+ public abstract void printTreeMethod(TreeNode node, boolean withSymbol);
//########################################################################
}
diff --git a/sources/meta/scalac/ast/MetaDefaultTreeFactory.java b/sources/meta/scalac/ast/MetaDefaultTreeFactory.java
index 957f46439a..fde4fe7773 100644
--- a/sources/meta/scalac/ast/MetaDefaultTreeFactory.java
+++ b/sources/meta/scalac/ast/MetaDefaultTreeFactory.java
@@ -13,10 +13,9 @@ public class MetaDefaultTreeFactory extends AbstractTreeMethodExpander {
//########################################################################
// Public Methods
- public void printTreeMethod(TreeNode node) {
- printTreeMethodHeader(node, "int pos");
- writer.lbrace();
- node.printNew(writer.print(node.name + " t = ")).println(";");
+ public void printTreeMethod(TreeNode node, boolean withSymbol) {
+ node.printMethod(writer, "int pos", withSymbol).lbrace();
+ node.printNew(writer.print(node + " t = "), withSymbol).println(";");
writer.println("t.pos = pos;");
writer.println("return t;");
writer.rbrace();
diff --git a/sources/meta/scalac/ast/MetaLazyTreeCopier.java b/sources/meta/scalac/ast/MetaLazyTreeCopier.java
index 56ed1e3e00..c389ab9404 100644
--- a/sources/meta/scalac/ast/MetaLazyTreeCopier.java
+++ b/sources/meta/scalac/ast/MetaLazyTreeCopier.java
@@ -13,26 +13,38 @@ public class MetaLazyTreeCopier extends AbstractTreeMethodExpander {
//########################################################################
// Public Methods
- public void printTreeMethod(TreeNode node) {
- printTreeMethodHeader(node, tree.t_Tree + " tree");
- writer.lbrace();
- writer.println(node.name + " t = (" + node.name + ")tree;");
- if (node.fields.length > 0) {
+ public void printTreeMethod(TreeNode node, boolean withSymbol) {
+ TreeField symbol = node.getSymbol();
+ node.printMethod(writer, tree.getFormal("tree"), withSymbol).lbrace();
+ if (!withSymbol && node.hasLinkedFields())
+ writer.println("assert tree.symbol() == null : "+
+ "\"tree's symbol is not null\";");
+ writer.print(node.getType(0)).print(" t = (").
+ print(node.getType(0)).println(")tree;");
+ TreeField[] fields = node.getFields(withSymbol);
+ // !!! why do we copy if there is no symbol and no field
+ if (withSymbol || node.fields.length > 0) {
writer.print("if (").indent();
- for (int i = 0; i < node.fields.length; i++) {
- if (i > 0) writer.println(" &&");
- String name = node.fields[i].name;
- writer.print("t." + name + " == " + name);
+ if (withSymbol) writer.print("t.symbol() == " + symbol);
+ for (int i = 0; i < fields.length; i++) {
+ if (i > 0 ? true : withSymbol) writer.println(" &&");
+ writer.print("t." + fields[i] + " == " + fields[i]);
}
writer.println(")");
writer.println("return t;").undent();
- writer.print("t = copier." + node.name + "(");
- node.printArgs(writer, "tree").println(");");
- writer.println("t.type = tree.type;");
- if (node.hasSymbol())writer.println("t.setSymbol(tree.symbol());");
}
- writer.println("return t;");
+ writer.print("return copier.");
+ node.printCall(writer, "tree", withSymbol).println(";");
writer.rbrace();
+
+ if (withSymbol && node.hasLinkedFields()) {
+ node.printMethod(writer, tree.getFormal("tree"), false, true);
+ writer.lbrace();
+ symbol.print(writer, true).println(" = tree.symbol();");
+ node.printCall(writer.print("return "), "tree", true).println(";");
+ writer.rbrace();
+ return;
+ }
}
//########################################################################
diff --git a/sources/meta/scalac/ast/MetaStrictTreeCopier.java b/sources/meta/scalac/ast/MetaStrictTreeCopier.java
index 9cc050396a..cd0ec6bf58 100644
--- a/sources/meta/scalac/ast/MetaStrictTreeCopier.java
+++ b/sources/meta/scalac/ast/MetaStrictTreeCopier.java
@@ -13,16 +13,30 @@ public class MetaStrictTreeCopier extends AbstractTreeMethodExpander {
//########################################################################
// Public Methods
- public void printTreeMethod(TreeNode node) {
- printTreeMethodHeader(node, tree.t_Tree + " tree");
- writer.lbrace();
- writer.print(node.name + " t = make." + node.name + "(");
- node.printArgs(writer, "tree.pos").println(");");
+ public void printTreeMethod(TreeNode node, boolean withSymbol) {
+ TreeField symbol = node.getSymbol();
+ node.printMethod(writer, tree.getFormal("tree"), withSymbol).lbrace();
+ if (!withSymbol && node.hasLinkedFields())
+ writer.println("assert tree.symbol() == null : "+
+ "\"tree's symbol is not null\";");
+ writer.print(node.getType(0)).print(" t = make.");
+ node.printCall(writer, "tree.pos", withSymbol).println(";");
writer.println("t.type = tree.type;");
- if (node.hasSymbol()) writer.println("t.setSymbol(tree.symbol());");
+ if (!withSymbol && node.hasSymbol() && !node.hasLinkedFields())
+ writer.println("t.setSymbol(tree.symbol());");
writer.println("return t;");
writer.rbrace();
+
+ if (withSymbol && node.hasLinkedFields()) {
+ node.printMethod(writer, tree.getFormal("tree"), false, true);
+ writer.lbrace();
+ symbol.print(writer, true).println(" = tree.symbol();");
+ node.printCall(writer.print("return "), "tree", true).println(";");
+ writer.rbrace();
+ }
}
//########################################################################
}
+
+
diff --git a/sources/meta/scalac/ast/MetaTransformer.java b/sources/meta/scalac/ast/MetaTransformer.java
index c4f2794851..79ebebaf2f 100644
--- a/sources/meta/scalac/ast/MetaTransformer.java
+++ b/sources/meta/scalac/ast/MetaTransformer.java
@@ -19,40 +19,52 @@ public class MetaTransformer extends AbstractTreeCaseExpander {
if (node.fields == null) {
writer.println("return tree;");
} else {
- writer.print("return copy." + node + "(tree");
- for (int i = 0; i < node.fields.length; i++) {
- writer.print(", ");
- if (Tree.isTree(node.fields[i].type))
- writer.print("transform(" + node.fields[i] + ")");
- else
- writer.print(node.fields[i].name);
+ if (node.hasSymbol()) {
+ writer.print("if (tree.symbol() != null)").lbrace();
+ printTransformNode(node, true);
+ writer.undent().print("} else").lbrace();
}
- writer.println(");");
+ printTransformNode(node, false);
+ if (node.hasSymbol()) writer.rbrace();
}
}
+ public void printTransformNode(TreeNode node, boolean withSymbol) {
+ TreeField[] fields = node.getFields(withSymbol);
+ writer.print("return copy." + node + "(tree");
+ if (withSymbol) writer.print(", tree.symbol()");
+ for (int i = 0; i < fields.length; i++) {
+ writer.print(", ");
+ if (Tree.isTree(fields[i].type))
+ writer.print("transform(" + fields[i].name + ")");
+ else
+ writer.print(fields[i].name);
+ }
+ writer.println(");");
+ }
+
public void printTransformArrays() {
- printTransformArrayOf(tree.t_Tree, false);
- printTransformArrayOf(tree.t_Trees, false);
+ for (int j = 1; j <= tree.arrays; j++)
+ printTransformArray(tree.getType(j), false);
for (int i = 0; i < tree.nodes.length; i++)
- for (int j = 0; j < tree.nodes[i].arrays; j++)
- printTransformArrayOf(tree.nodes[i].getType(j), j == 0);
+ for (int j = 1; j <= tree.nodes[i].arrays; j++)
+ printTransformArray(tree.nodes[i].getType(j), j == 1);
}
- public void printTransformArrayOf(Type type, boolean needCast) {
- String cast = needCast ? "(" + type + ")" : "";
- writer.print("public "+type+"[] transform("+type+"[] ts)");
- writer.lbrace();
- writer.print("for (int i = 0; i < ts.length; i++)");
- writer.lbrace();
- writer.println((needCast?tree.t_Tree:type)+" t = transform(ts[i]);");
- writer.print("if (t != ts[i])");
- writer.lbrace();
- writer.println(type+"[] res = new "+type.newArray("[ts.length]")+";");
+ public void printTransformArray(Type type, boolean needCast) {
+ Type item = type.getItemType();
+ Type erased = needCast ? tree.getType(0) : item;
+ String cast = needCast ? "(" + item + ")" : "";
+ writer.print("public ").print(type).print(" transform").
+ print("(").print(type).print(" ts)").lbrace();
+ writer.print("for (int i = 0; i < ts.length; i++)").lbrace();
+ writer.println(erased + " t = transform(ts[i]);");
+ writer.print("if (t != ts[i])").lbrace();
+ writer.println(type+" res = new "+item.newArray("[ts.length]")+";");
writer.println("System.arraycopy(ts, 0, res, 0, i);");
- writer.println("res[i] = "+cast+"t;");
- writer.println("for (int j = i + 1; j < ts.length; j++)");
- writer.println("res[j] = "+cast+"transform(ts[j]);");
+ writer.println("res[i++] = "+cast+"t;");
+ writer.print("for (; i < ts.length; i++)").
+ println("res[i] = "+cast+"transform(ts[i]);");
writer.println("return res;");
writer.rbrace();
writer.rbrace();
diff --git a/sources/meta/scalac/ast/MetaTraverser.java b/sources/meta/scalac/ast/MetaTraverser.java
index 4e00b924c9..0f166510db 100644
--- a/sources/meta/scalac/ast/MetaTraverser.java
+++ b/sources/meta/scalac/ast/MetaTraverser.java
@@ -8,6 +8,8 @@
package meta.scalac.ast;
+import meta.java.Type;
+
public class MetaTraverser extends AbstractTreeCaseExpander {
//########################################################################
@@ -21,5 +23,22 @@ public class MetaTraverser extends AbstractTreeCaseExpander {
writer.println("return;");
}
+ public void printTraverseArrays() {
+ int max = tree.arrays;
+ for (int i = 0; i < tree.nodes.length; i++)
+ max = Math.max(max, tree.nodes[i].arrays);
+ for (int i = 1; i <= max; i++)
+ printTraverseArray(tree.getType(i));
+ }
+
+ public void printTraverseArray(Type type) {
+ writer.print("public void traverse").
+ print("(").print(type).print(" trees)").lbrace();
+ writer.print("for (int i = 0; i < trees.length; i++) ").
+ println("traverse(trees[i]);");
+ writer.rbrace();
+ writer.line();
+ }
+
//########################################################################
}
diff --git a/sources/meta/scalac/ast/MetaTree.java b/sources/meta/scalac/ast/MetaTree.java
index 461ec184f5..a8b5979636 100644
--- a/sources/meta/scalac/ast/MetaTree.java
+++ b/sources/meta/scalac/ast/MetaTree.java
@@ -16,20 +16,22 @@ public class MetaTree extends AbstractTreeExpander {
// Public Methods
public void printEmptyArrays() {
- writer.print("public static final ");
- writer.print(tree.t_Trees.toString());
- writer.print(" EMPTY_ARRAY = new ").print(tree.NAME).println("[0];");
+ printEmptyArrays(tree.getType(0), "EMPTY", tree.arrays);
for (int i = 0; i < tree.nodes.length; i++) {
TreeNode node = tree.nodes[i];
- for (int j = 1; j <= node.arrays; j++) {
- writer.print("public static final ");
- writer.print(node.getType(j).toString());
- writer.space().print(node.name).print("_EMPTY");
- for (int k = 0; k < j; k++) writer.print("_ARRAY");
- writer.print(" = new ").print(node.name).print("[0]");
- for (int k = 1; k < j; k++) writer.print("[]");
- writer.println(";");
- }
+ printEmptyArrays(node.getType(0), node + "_EMPTY", node.arrays);
+ }
+ }
+
+ public void printEmptyArrays(Type base, String prefix, int maxRank) {
+ Type type = base;
+ for (int rank = 1; rank <= maxRank; rank++) {
+ type = Type.Array(type);
+ writer.print("public static final ").print(type).print(" "+prefix);
+ for (int i = 0; i < rank; i++) writer.print("_ARRAY");
+ writer.print(" = new ").print(base).print("[0]");
+ for (int i = 1; i < rank; i++) writer.print("[]");
+ writer.println(";");
}
}
@@ -46,39 +48,38 @@ public class MetaTree extends AbstractTreeExpander {
"- introduced by: " + node.start.name,
"- eliminated by: " + node.stop.name,
});
- writer.print("public case ").print(node.name);
+ node.printDecl(writer.print("public case "), null, false);
if (node.fields != null) {
- node.printParams(writer.print("(")).print(")");
writer.lbrace();
writer.println("assert CheckTreeNodes.instance.checkNode(this);");
writer.rbrace();
- } else if (node == tree.n_Empty) {
- writer.print("; static { "+node.name+".type = ").
- print(tree.t_Type).println(".NoType; }");
} else {
writer.println(";");
}
+ if (node == tree.n_Empty)
+ writer.print("static { " + node + ".type = Type.NoType; }");
writer.println();
}
private String description(TreeKind kind) {
switch (kind) {
- case Any: return "this tree is of any kind";
+ case Any : return "this tree is of any kind";
case Type: return "this tree is a type";
case Term: return "this tree is a term";
case Dual: return "this tree is a type or a term";
- case Test: return "this tree is a type or a term (determined by the kind of the name field)";
+ case Test: return "this tree is a type or a term " +
+ "(determined by the kind of the name field)";
case None: return "this tree is neither a type nor a term";
- default : throw new Error(kind.getClass().getName());
+ default : throw new Error(kind.getClass().getName());
}
}
private String description(TreeSymbol symbol) {
switch (symbol) {
- case NoSym : return "this tree has no symbol";
- case HasSym: return "this tree references a symbol";
- case DefSym: return "this tree defines a symbol";
- default : throw new Error(symbol.getClass().getName());
+ case NoSym : return "this tree has no symbol";
+ case HasSym(_, false): return "this tree references a symbol";
+ case HasSym(_, true ): return "this tree defines a symbol";
+ default : throw new Error(symbol.getClass().getName());
}
}
@@ -88,9 +89,9 @@ public class MetaTree extends AbstractTreeExpander {
}
private void printIsKind(TreeNode[] nodes, TreeKind kind) {
- writer.println("/** Returns true if this tree is a " + kind.toString().toLowerCase() + ". */");
- writer.print("public boolean is" + kind + "()");
- writer.lbrace();
+ writer.println("/** Returns true if this tree is a " +
+ kind.toString().toLowerCase() + ". */");
+ writer.print("public boolean is" + kind + "()").lbrace();
writer.println("switch (this) {");
for (int i = 0; i < nodes.length; i++)
@@ -136,63 +137,75 @@ public class MetaTree extends AbstractTreeExpander {
}
public void printExtClasses() {
- for (int i = 0; i < tree.nodes.length; i++)
- printExtTreeNode(tree.nodes[i]);
+ for (int i = 0;i < tree.nodes.length;i++) printExtClass(tree.nodes[i]);
}
- private void printExtTreeNode(TreeNode node) {
- if (node.symbol == TreeSymbol.NoSym) return;
- writer.print("public static class Ext"+node+" extends "+node);
- writer.lbrace();
- writer.print("private ").print(tree.t_Symbol).println(" symbol;");
+ private void printExtClass(TreeNode node) {
+ TreeField symbol = node.getSymbol();
+ if (symbol == null) return;
+ writer.print("public static class Ext"+node+" extends "+node).lbrace();
+ symbol.print(writer.print("private "), true).println(";");
writer.println();
- node.printParams(writer.print("public Ext"+node.name+"(")).print(")");
- writer.lbrace();
- node.printArgs(writer.print("super(")).println(");");
- writer.rbrace();
+ printExtConstructor(node, false);
+ printExtConstructor(node, true);
writer.println();
- writer.print("public boolean hasSymbol()");
- writer.lbrace();
+ writer.print("public boolean hasSymbol()").lbrace();
writer.println("return true;");
writer.rbrace();
writer.println();
- if (node.symbol == TreeSymbol.DefSym) {
- writer.print("public boolean definesSymbol()");
- writer.lbrace();
+ if (node.definesSymbol()) {
+ writer.print("public boolean definesSymbol()").lbrace();
writer.println("return true;");
writer.rbrace();
writer.println();
}
- writer.print("public ").print(tree.t_Symbol).print(" symbol()");
+ writer.print("public ").print(symbol.type).print(" symbol()");
writer.lbrace();
- writer.println("return symbol;");
+ writer.println("return " + symbol + ";");
writer.rbrace();
writer.println();
- writer.print("public Tree setSymbol(").print(tree.t_Symbol).print(" symbol)");
- writer.lbrace();
- writer.println("this.symbol = symbol;");
- if (node.hasLinkedFields()) {
- writer.print("if (symbol != null)").lbrace();
- for (int i = 0; i < node.fields.length; i++) {
- TreeField field = node.fields[i];
- TreeFieldLink link = field.link;
- if (link == null) continue;
- writer.println("this."+field+" = symbol."+link.getLink()+";");
- }
- writer.rbrace();
+ writer.print("public ").print(tree.getType(0)).print(" setSymbol");
+ symbol.print(writer.print("("), true).print(")").lbrace();
+ printSetSymbol(symbol);
+ for (int i = 0; i < node.fields.length; i++) {
+ TreeField field = node.fields[i];
+ TreeFieldLink link = field.link;
+ if (link == null) continue;
+ link.print(writer.print("this."+field+" = "),symbol).println(";");
}
writer.println("return this;");
writer.rbrace();
- writer.println();
writer.rbrace();
writer.println();
}
+ private void printExtConstructor(TreeNode node, boolean withSymbol) {
+ node.printDecl(writer.print("public Ext"), null, withSymbol).lbrace();
+ TreeField symbol = node.getSymbol();
+ writer.print("super(");
+ for (int i = 0; i < node.fields.length; i++) {
+ if (i > 0) writer.print(", ");
+ if (withSymbol && node.fields[i].link != null) {
+ node.fields[i].link.print(writer, symbol);
+ } else {
+ writer.print(node.fields[i].name);
+ }
+ }
+ writer.println(");");
+ if (withSymbol) printSetSymbol(symbol);
+ writer.rbrace();
+ }
+
+ private void printSetSymbol(TreeField symbol) {
+ writer.println("assert " + symbol + " != null : \"null symbol\";");
+ writer.println("this." + symbol + " = " + symbol + ";");
+ }
+
//########################################################################
}
diff --git a/sources/meta/scalac/ast/MetaTreeCopier.java b/sources/meta/scalac/ast/MetaTreeCopier.java
index 5ee43f4f90..785c3a99da 100644
--- a/sources/meta/scalac/ast/MetaTreeCopier.java
+++ b/sources/meta/scalac/ast/MetaTreeCopier.java
@@ -13,9 +13,13 @@ public class MetaTreeCopier extends AbstractTreeMethodExpander {
//########################################################################
// Public Methods
- public void printTreeMethod(TreeNode node) {
- printTreeMethodHeader(node, tree.t_Tree + " tree");
+ public void printTreeMethod(TreeNode node, boolean withSymbol) {
+ node.printMethod(writer,tree.getFormal("tree"),withSymbol);
writer.println(";");
+ if (withSymbol && node.hasLinkedFields()) {
+ node.printMethod(writer, tree.getFormal("tree"), false, true);
+ writer.println(";");
+ }
}
//########################################################################
diff --git a/sources/meta/scalac/ast/MetaTreeFactory.java b/sources/meta/scalac/ast/MetaTreeFactory.java
index f7222b402b..28b1f381c9 100644
--- a/sources/meta/scalac/ast/MetaTreeFactory.java
+++ b/sources/meta/scalac/ast/MetaTreeFactory.java
@@ -13,9 +13,8 @@ public class MetaTreeFactory extends AbstractTreeMethodExpander {
//########################################################################
// Public Methods
- public void printTreeMethod(TreeNode node) {
- printTreeMethodHeader(node, "int pos");
- writer.println(";");
+ public void printTreeMethod(TreeNode node, boolean withSymbol) {
+ node.printMethod(writer, "int pos", withSymbol).println(";");
}
//########################################################################
diff --git a/sources/meta/scalac/ast/Tree.java b/sources/meta/scalac/ast/Tree.java
index c06f3c6437..a7a933069b 100644
--- a/sources/meta/scalac/ast/Tree.java
+++ b/sources/meta/scalac/ast/Tree.java
@@ -18,32 +18,53 @@ import meta.scalac.Phase;
public class Tree {
//########################################################################
- // Public Constants
+ // Private Fields
- public static final String PACKAGE = "scalac.ast";
- public static final String NAME = "Tree";
+ private final TreeKind
+ Any = TreeKind.Any,
+ Type = TreeKind.Type,
+ Term = TreeKind.Term,
+ Dual = TreeKind.Dual,
+ Test = TreeKind.Test,
+ None = TreeKind.None;
- //########################################################################
- // Private Constants
+ private final Type
+ t_int = TreeType.INT,
+ t_Object = TreeType.Reference(null, "Object"),
+ t_Global = TreeType.Reference("scalac", "Global"),
+ t_Unit = TreeType.Reference("scalac", "Unit"),
+ t_TreeGen = TreeType.Reference("scalac.ast", "TreeGen"),
+ t_Symbol = TreeType.Reference("scalac.symtab", "Symbol"),
+ t_Type = TreeType.Reference("scalac.symtab", "Type"),
+ t_Name = TreeType.Name(Any),
+ t_TypeName = TreeType.Name(Type),
+ t_TermName = TreeType.Name(Term),
+ t_TestName = TreeType.Name(Test),
+ t_Names = TreeType.Array(t_Name),
+ t_Tree = getType(0),
+ t_TypeTree = getType(0, Type),
+ t_TermTree = getType(0, Term),
+ t_Trees = getType(1),
+ t_TypeTrees = getType(1, Type),
+ t_TermTrees = getType(1, Term);
- private static final TreeKind Any = TreeKind.Any;
- private static final TreeKind Type = TreeKind.Type;
- private static final TreeKind Term = TreeKind.Term;
- private static final TreeKind Dual = TreeKind.Dual;
- private static final TreeKind Test = TreeKind.Test;
- private static final TreeKind None = TreeKind.None;
+ private final TreeFieldLink
+ SymFlags = TreeFieldLink.SymFlags,
+ SymName = TreeFieldLink.SymName;
- private static final TreeSymbol NoSym = TreeSymbol.NoSym;
- private static final TreeSymbol HasSym = TreeSymbol.HasSym;
- private static final TreeSymbol DefSym = TreeSymbol.DefSym;
+ private final TreeField
+ tree_symbol = new TreeField(t_Symbol, "symbol");
- private static final TreeFieldLink SymFlags = TreeFieldLink.SymFlags;
- private static final TreeFieldLink SymName = TreeFieldLink.SymName;
+ private final TreeSymbol
+ NoSym = TreeSymbol.NoSym,
+ HasSym = TreeSymbol.HasSym(tree_symbol, false),
+ DefSym = TreeSymbol.HasSym(tree_symbol, true);
- private final List list = new ArrayList();
+ private final List list
+ = new ArrayList();
//########################################################################
- // Public Constants
+ // Public Fields
public final TreeNode
n_Bad = node("Bad" , Any , HasSym),
@@ -57,7 +78,7 @@ public class Tree {
n_TypeDef = node("TypeDef" , None, DefSym),
n_Import = node("Import" , None, HasSym),
n_CaseDef = node("CaseDef" , None, NoSym),
- n_Template = node("Template" , None, HasSym), // !!! HasSym
+ n_Template = node("Template" , None, HasSym),
n_LabelDef = node("LabelDef" , Term, DefSym),
n_Block = node("Block" , Term, NoSym),
n_Tuple = node("Tuple" , Term, NoSym),
@@ -83,38 +104,7 @@ public class Tree {
n_CovariantType = node("CovariantType" , Type, NoSym);
public final TreeNode[] nodes;
-
- public final Type
- t_int = TreeType.INT,
- t_Object = TreeType.Reference(null, "Object"),
- t_Global = TreeType.Reference("scalac", "Global"),
- t_Unit = TreeType.Reference("scalac", "Unit"),
- t_TreeGen = TreeType.Reference("scalac.ast", "TreeGen"),
- t_Symbol = TreeType.Reference("scalac.symtab", "Symbol"),
- t_Type = TreeType.Reference("scalac.symtab", "Type"),
- t_Debug = TreeType.Reference("scalac.util", "Debug"),
- t_Name = TreeType.Name(Any),
- t_TypeName = TreeType.Name(Type),
- t_TermName = TreeType.Name(Term),
- t_TestName = TreeType.Name(Test),
- t_Names = TreeType.Array(t_Name),
- t_Tree = TreeType.Tree(Any),
- t_TypeTree = TreeType.Tree(Type),
- t_TermTree = TreeType.Tree(Term),
- t_Trees = TreeType.Array(t_Tree),
- t_TypeTrees = TreeType.Array(t_TypeTree),
- t_TermTrees = TreeType.Array(t_TermTree),
- t_Treess = TreeType.Array(t_Trees),
- t_ValDef = n_ValDef.getType(0),
- t_ValDefs = n_ValDef.getType(1),
- t_ValDefss = n_ValDef.getType(2),
- t_TypeDef = n_TypeDef.getType(0),
- t_TypeDefs = n_TypeDef.getType(1),
- t_Template = n_Template.getType(0),
- t_CaseDef = n_CaseDef.getType(0),
- t_CaseDefs = n_CaseDef.getType(1),
- t_Ident = n_Ident.getType(0),
- t_Idents = n_Ident.getType(1);
+ public int arrays;
//########################################################################
// Public Constructors
@@ -136,16 +126,16 @@ public class Tree {
setRange(Phase.PARSER, Phase.END).
addField(t_int, "mods", SymFlags).
addField(t_TypeName, "name", SymName).
- addField(t_TypeDefs, "tparams").
- addField(t_ValDefss, "vparams").
+ addField(n_TypeDef.getType(1), "tparams").
+ addField(n_ValDef.getType(2), "vparams").
addField(t_TypeTree, "tpe").
- addField(t_Template, "impl");
+ addField(n_Template.getType(0), "impl");
n_PackageDef.
setDescription("Package declaration").
setRange(Phase.PARSER, Phase.UNKNOWN).
addField(t_TermTree, "packaged").
- addField(t_Template, "impl");
+ addField(n_Template.getType(0), "impl");
n_ModuleDef.
setDescription("Module declaration").
@@ -153,7 +143,7 @@ public class Tree {
addField(t_int, "mods", SymFlags).
addField(t_TermName, "name", SymName).
addField(t_TypeTree, "tpe").
- addField(t_Template, "impl");
+ addField(n_Template.getType(0), "impl");
n_ValDef.
setDescription("Value declaration (var or let)").
@@ -176,8 +166,8 @@ public class Tree {
setRange(Phase.PARSER, Phase.END).
addField(t_int, "mods", SymFlags).
addField(t_TermName, "name", SymName).
- addField(t_TypeDefs, "tparams").
- addField(t_ValDefss, "vparams").
+ addField(n_TypeDef.getType(1), "tparams").
+ addField(n_ValDef.getType(2), "vparams").
addField(t_TypeTree, "tpe").
addField(t_TermTree, "rhs");
@@ -227,13 +217,13 @@ public class Tree {
n_Visitor.
setDescription("Visitor (a sequence of cases)").
setRange(Phase.PARSER, Phase.TRANSMATCH).
- addField(t_CaseDefs, "cases");
+ addField(n_CaseDef.getType(1), "cases");
n_Function.
setDescription("Anonymous function").
setRange(Phase.PARSER, Phase.ANALYZER).
- addField(t_ValDefs, "vparams").
+ addField(n_ValDef.getType(1), "vparams").
addField(t_TermTree, "body");
n_Assign.
@@ -252,7 +242,7 @@ public class Tree {
n_New.
setDescription("Instantiation").
setRange(Phase.PARSER, Phase.END).
- addField(t_Template, "templ");
+ addField(n_Template.getType(0), "templ");
n_Typed.
setDescription("Type annotation").
@@ -355,6 +345,22 @@ public class Tree {
}
//########################################################################
+ // Public Methods
+
+ public Type getType(int rank) {
+ return getType(rank, Any);
+ }
+
+ public Type getType(int rank, TreeKind kind) {
+ arrays = Math.max(arrays , rank);
+ return rank==0 ? TreeType.Tree(kind) : TreeType.Array(getType(rank-1));
+ }
+
+ public String getFormal(String name) {
+ return getType(0) + " " + name;
+ }
+
+ //########################################################################
// Private Methods
private TreeNode node(String name, TreeKind kind, TreeSymbol symbol) {
diff --git a/sources/meta/scalac/ast/TreeField.java b/sources/meta/scalac/ast/TreeField.java
index f27c8c1698..19df9cb42e 100644
--- a/sources/meta/scalac/ast/TreeField.java
+++ b/sources/meta/scalac/ast/TreeField.java
@@ -9,6 +9,7 @@
package meta.scalac.ast;
import meta.java.Type;
+import meta.java.JavaWriter;
/** This class describes a tree node field. */
public class TreeField {
@@ -23,6 +24,10 @@ public class TreeField {
//########################################################################
// Public Constructors
+ public TreeField(Type type, String name) {
+ this(type, name, null);
+ }
+
public TreeField(Type type, String name, TreeFieldLink link) {
this.type = type;
this.name = name;
@@ -30,8 +35,26 @@ public class TreeField {
}
//########################################################################
+ // Public Function
+
+ public static JavaWriter print(JavaWriter writer, TreeField[] fields,
+ boolean withType)
+ {
+ for (int i = 0; i < fields.length; i++) {
+ if (i > 0) writer.print(", ");
+ fields[i].print(writer, withType);
+ }
+ return writer;
+ }
+
+ //########################################################################
// Public Methods
+ public JavaWriter print(JavaWriter writer, boolean withType) {
+ if (withType) writer.print(type).space();
+ return writer.print(name);
+ }
+
public String toString() {
return name;
}
diff --git a/sources/meta/scalac/ast/TreeFieldLink.java b/sources/meta/scalac/ast/TreeFieldLink.java
index b338ccd6eb..62e8dcfb10 100644
--- a/sources/meta/scalac/ast/TreeFieldLink.java
+++ b/sources/meta/scalac/ast/TreeFieldLink.java
@@ -8,6 +8,8 @@
package meta.scalac.ast;
+import meta.java.JavaWriter;
+
/**
* This class describes the possible links between a given field of a
* tree and the symbol of that tree.
@@ -50,5 +52,9 @@ public class TreeFieldLink {
}
}
+ public JavaWriter print(JavaWriter writer, TreeField symbol) {
+ return writer.print(symbol.name).print('.').print(getLink());
+ }
+
//########################################################################
}
diff --git a/sources/meta/scalac/ast/TreeNode.java b/sources/meta/scalac/ast/TreeNode.java
index 5a985bc3ae..340eaa8109 100644
--- a/sources/meta/scalac/ast/TreeNode.java
+++ b/sources/meta/scalac/ast/TreeNode.java
@@ -44,30 +44,7 @@ public class TreeNode {
}
//########################################################################
- // Public Methods
-
- public boolean hasExtClass() {
- return hasSymbol();
- }
-
- public boolean hasSymbol() {
- return symbol == symbol.HasSym || symbol == symbol.DefSym;
- }
-
- public boolean hasLinkedFields() {
- for (int i = 0; i < fields.length; i++)
- if (fields[i].link != null) return true;
- return false;
- }
-
- public boolean definesSymbol() {
- return symbol == symbol.DefSym;
- }
-
- public Type getType(int rank) {
- arrays = Math.max(arrays , rank);
- return rank == 0 ? TreeType.Node(this) : Type.Array(getType(rank - 1));
- }
+ // Public Methods - Initializing
public TreeNode setDescription(String description) {
this.description = description;
@@ -90,9 +67,8 @@ public class TreeNode {
}
public TreeNode addField(Type type, String name, TreeFieldLink link) {
- if (link != null)
- if (symbol != TreeSymbol.HasSym && symbol != TreeSymbol.DefSym)
- throw new Error("node "+this+" may not have linked fields");
+ if (link != null && !hasSymbol())
+ throw new Error("node "+this+" may not have linked fields");
TreeField[] array = new TreeField[fields.length + 1];
for (int i = 0; i < fields.length; i++) array[i] = fields[i];
array[fields.length] = new TreeField(type, name, link);
@@ -100,52 +76,60 @@ public class TreeNode {
return this;
}
- public JavaWriter printCase(JavaWriter writer, boolean wildcards) {
- writer.print("case ").print(name);
- if (fields!=null) printParams(writer.print("("),wildcards).print(")");
- return writer.print(":").space();
- }
+ //########################################################################
+ // Public Methods - Querying
- public JavaWriter printParams(JavaWriter writer) {
- return printParams(writer, false);
+ public Type getType(int rank) {
+ arrays = Math.max(arrays , rank);
+ return rank == 0 ? TreeType.Node(this) : Type.Array(getType(rank - 1));
}
- public JavaWriter printParams(JavaWriter writer, String prefix) {
- return printParams(printPrefix(writer, prefix));
+ public boolean hasExtClass() {
+ return hasSymbol();
}
- public JavaWriter printParams(JavaWriter writer, boolean wildcards) {
- if (fields != null) for (int i = 0; i < fields.length; i++) {
- if (i > 0) writer.print(", ");
- if (wildcards) writer.print("_");
- else writer.print(fields[i].type).space().print(fields[i].name);
+ public boolean hasSymbol() {
+ switch (symbol) {
+ case TreeSymbol.HasSym(_, _):
+ return true;
+ default:
+ return false;
}
- return writer;
}
- public JavaWriter printArgs(JavaWriter writer) {
- if (fields != null) for (int i = 0; i < fields.length; i++) {
- if (i > 0) writer.print(", ");
- writer.print(fields[i].name);
+ public boolean definesSymbol() {
+ switch (symbol) {
+ case TreeSymbol.HasSym(_, true):
+ return true;
+ default:
+ return false;
}
- return writer;
}
- public JavaWriter printArgs(JavaWriter writer, String prefix) {
- return printArgs(printPrefix(writer, prefix));
+ public TreeField getSymbol() {
+ switch (symbol) {
+ case TreeSymbol.HasSym(TreeField field, _):
+ return field;
+ default:
+ return null;
+ }
}
- public JavaWriter printPrefix(JavaWriter writer, String prefix) {
- if (prefix != null) {
- writer.print(prefix);
- if (fields != null && fields.length > 0) writer.print(", ");
- }
- return writer;
+ public boolean hasLinkedFields() {
+ for (int i = 0; i < fields.length; i++)
+ if (fields[i].link != null) return true;
+ return false;
}
- public JavaWriter printNew(JavaWriter writer) {
- String classname = (hasExtClass() ? "Ext" : "") + name;
- return printArgs(writer.print("new " + classname + "(")).print(")");
+ public TreeField[] getFields(boolean withoutLinkedFields) {
+ if (fields == null || !withoutLinkedFields) return fields;
+ int count = 0;;
+ for (int i = 0; i < fields.length; i++)
+ if (fields[i].link == null) count++;
+ TreeField[] array = new TreeField[count];
+ for (int i = 0, j = 0; i < fields.length; i++)
+ if (fields[i].link == null) array[j++] = fields[i];
+ return array;
}
public String toString() {
@@ -153,4 +137,95 @@ public class TreeNode {
}
//########################################################################
+ // Public Methods - Printing
+
+ public JavaWriter printCase(JavaWriter writer, boolean withWildcards) {
+ writer.print("case ");
+ if (fields != null && withWildcards) {
+ writer.print(name).print('(');
+ for (int i = 0; i < fields.length; i++) {
+ if (i > 0) writer.print(", ");
+ writer.print("_");
+ }
+ writer.print(')');
+ } else {
+ printDecl(writer, null, false);
+ }
+ return writer.print(":").space();
+ }
+
+ public JavaWriter printNew(JavaWriter writer, boolean withSymbol) {
+ writer.print("new ");
+ if (hasExtClass()) writer.print("Ext");
+ return printCall(writer, null, withSymbol);
+ }
+
+ public JavaWriter printMethod(JavaWriter writer, String prefix,
+ boolean withSymbol)
+ {
+ return printMethod(writer, prefix, withSymbol, withSymbol);
+ }
+
+ public JavaWriter printMethod(JavaWriter writer, String prefix,
+ boolean withSymbol, boolean withoutLinkedFields)
+ {
+ writer.print("public ").print(name).space();
+ return printDecl(writer, prefix, withSymbol, withoutLinkedFields);
+ }
+
+ public JavaWriter printDecl(JavaWriter writer, String prefix,
+ boolean withSymbol)
+ {
+ return printDecl(writer, prefix, withSymbol, withSymbol);
+ }
+
+ public JavaWriter printDecl(JavaWriter writer, String prefix,
+ boolean withSymbol, boolean withoutLinkedFields)
+ {
+ return printPattern(writer,true,prefix,withSymbol,withoutLinkedFields);
+ }
+
+ public JavaWriter printCall(JavaWriter writer, String prefix,
+ boolean withSymbol)
+ {
+ return printCall(writer, prefix, withSymbol, withSymbol);
+ }
+
+ public JavaWriter printCall(JavaWriter writer, String prefix,
+ boolean withSymbol, boolean withoutLinkedFields)
+ {
+ return printPattern(
+ writer, false, prefix, withSymbol, withoutLinkedFields);
+ }
+
+ public JavaWriter printPattern(JavaWriter writer, boolean withType,
+ String prefix, boolean withSymbol, boolean withoutLinkedFields)
+ {
+ writer.print(name);
+ if (fields != null || prefix != null || withSymbol) {
+ writer.print('(');
+ printFields(writer,withType,prefix,withSymbol,withoutLinkedFields);
+ writer.print(')');
+ }
+ return writer;
+ }
+
+ public JavaWriter printFields(JavaWriter writer, boolean withType,
+ String prefix, boolean withSymbol, boolean withoutLinkedFields)
+ {
+ TreeField[] fields = getFields(withoutLinkedFields);
+ if (prefix != null) {
+ writer.print(prefix);
+ if (withSymbol || (fields != null && fields.length > 0))
+ writer.print(", ");
+ }
+ if (withSymbol) {
+ getSymbol().print(writer, withType);
+ if (fields != null && fields.length > 0) writer.print(", ");
+ }
+ TreeField.print(writer, fields, withType);
+ return writer;
+ }
+
+ //########################################################################
}
diff --git a/sources/meta/scalac/ast/TreeSymbol.java b/sources/meta/scalac/ast/TreeSymbol.java
index 8040239800..1e53be4013 100644
--- a/sources/meta/scalac/ast/TreeSymbol.java
+++ b/sources/meta/scalac/ast/TreeSymbol.java
@@ -18,10 +18,7 @@ public class TreeSymbol {
public case NoSym;
/** Indicates the presence of a symbol. */
- public case HasSym;
-
- /** Indicates the presence of a symbol that is define here. */
- public case DefSym;
+ public case HasSym(TreeField field, boolean isDef);
//########################################################################
}
diff --git a/sources/meta/scalac/ast/TreeType.java b/sources/meta/scalac/ast/TreeType.java
index f15e7ec676..52c2e6d9b3 100644
--- a/sources/meta/scalac/ast/TreeType.java
+++ b/sources/meta/scalac/ast/TreeType.java
@@ -14,15 +14,14 @@ import meta.java.Type;
public class TreeType extends Type {
//########################################################################
- // Public Constants
+ // Private Constants
- // !!!
- public static final String NAME_PACKAGE = "scalac.util";
- public static final String NAME_NAME = "Name";
- public static final String NAME_FULLNAME = NAME_PACKAGE + "." + NAME_NAME;
- public static final String TREE_PACKAGE = meta.scalac.ast.Tree.PACKAGE;
- public static final String TREE_NAME = meta.scalac.ast.Tree.NAME;
- public static final String TREE_FULLNAME = TREE_PACKAGE + "." + TREE_NAME;
+ private static final String NAME_PACKAGE = "scalac.util";
+ private static final String NAME_NAME = "Name";
+ private static final String NAME_FULLNAME = NAME_PACKAGE + "." + NAME_NAME;
+ private static final String TREE_PACKAGE = "scalac.ast";
+ private static final String TREE_NAME = "Tree";
+ private static final String TREE_FULLNAME = TREE_PACKAGE + "." + TREE_NAME;
//########################################################################
// Public Cases
diff --git a/sources/scalac/ast/SubstTransformer.java b/sources/scalac/ast/SubstTransformer.java
index 3d4f97b698..2bfecaaa1c 100644
--- a/sources/scalac/ast/SubstTransformer.java
+++ b/sources/scalac/ast/SubstTransformer.java
@@ -147,16 +147,12 @@ public class SubstTransformer extends Transformer {
// 2. types reflect the ones in symbols.
// 3. modifiers reflect the ones in symbols.
public Tree syncTree(Tree tree) {
- Name newName = null;
Type newType = null;
- int newMods = -1;
+ Symbol sym = null;
if (tree.hasSymbol()) {
- Symbol sym = tree.symbol();
-
- newName = sym.name;
+ sym = tree.symbol();
newType = smApplier.apply(typeMap.apply(sym.nextInfo()));
- newMods = sym.flags;
}
// !!! Do we really need to copy ? transformer's copier is strict so
@@ -169,19 +165,17 @@ public class SubstTransformer extends Transformer {
Tree tpe,
Tree.Template impl) :
return simpleCopy
- .ClassDef(tree, newMods, newName, tparams, vparams, tpe, impl);
+ .ClassDef(tree, sym, tparams, vparams, tpe, impl);
case ModuleDef(_, _, Tree tpe, Template impl):
return simpleCopy.ModuleDef(tree,
- newMods,
- newName,
+ sym,
gen.mkType(tpe.pos, newType),
impl);
case ValDef(int mods, Name name, Tree tpe, Tree rhs):
return simpleCopy.ValDef(tree,
- newMods,
- newName,
+ sym,
gen.mkType(tpe.pos, newType),
rhs);
@@ -192,18 +186,17 @@ public class SubstTransformer extends Transformer {
Tree tpe,
Tree rhs):
return simpleCopy.DefDef(tree,
- newMods,
- newName,
+ sym,
tparams,
vparams,
gen.mkType(tpe.pos, newType.resultType()),
rhs);
case Select(Tree qualifier, _):
- return simpleCopy.Select(tree, qualifier, newName);
+ return simpleCopy.Select(tree, sym, qualifier);
case Ident(_):
- return simpleCopy.Ident(tree, newName);
+ return simpleCopy.Ident(tree, sym);
// TODO add a case for TypeDef?
diff --git a/sources/scalac/ast/Traverser.java.tmpl b/sources/scalac/ast/Traverser.java.tmpl
index f46d40b09b..2685a69ecc 100644
--- a/sources/scalac/ast/Traverser.java.tmpl
+++ b/sources/scalac/ast/Traverser.java.tmpl
@@ -25,13 +25,7 @@ public class Traverser {
{#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]);
- }
+ {#TraverseArrays#}
//########################################################################
}
diff --git a/sources/scalac/transformer/AddAccessors.java b/sources/scalac/transformer/AddAccessors.java
index 54ebc5ab21..615ef1bd38 100644
--- a/sources/scalac/transformer/AddAccessors.java
+++ b/sources/scalac/transformer/AddAccessors.java
@@ -55,8 +55,8 @@ public class AddAccessors extends Transformer {
public Tree transform(Tree tree) {
switch (tree) {
- case ClassDef(int mods, // :
- Name name,
+ case ClassDef(_, // :
+ _,
Tree.TypeDef[] tparams,
Tree.ValDef[][] vparams,
Tree tpe,
@@ -108,8 +108,7 @@ public class AddAccessors extends Transformer {
Tree[] newBodyA = (Tree[])newBody.toArray(new Tree[newBody.size()]);
return copy.ClassDef(tree,
- mods,
- name,
+ clsSym,
transform(tparams),
transform(vparams),
transform(tpe),
@@ -126,24 +125,24 @@ public class AddAccessors extends Transformer {
return super.transform(tree);
}
- case Select(Tree qualifier, Name selector): {
+ case Select(Tree qualifier, _): {
Symbol sym = tree.symbol();
assert sym.kind != Kinds.NONE : tree;
if (sym.owner().isPrimaryConstructor())
return gen.Apply(gen.Select(transform(qualifier), accessor(sym)),
Tree.EMPTY_ARRAY);
else
- return copy.Select(tree, transform(qualifier), selector);
+ return copy.Select(tree, sym, transform(qualifier));
}
- case Ident(Name name): {
+ case Ident(_): {
Symbol sym = tree.symbol();
if (inClassContext
- && name.isTermName()
+ && sym.name.isTermName()
&& sym.owner().isPrimaryConstructor())
return gen.Apply(gen.Ident(accessor(sym)), Tree.EMPTY_ARRAY);
else
- return copy.Ident(tree, name);
+ return copy.Ident(tree, sym);
}
default:
diff --git a/sources/scalac/transformer/AddInterfaces.java b/sources/scalac/transformer/AddInterfaces.java
index 5de93523ca..4c9cfd010f 100644
--- a/sources/scalac/transformer/AddInterfaces.java
+++ b/sources/scalac/transformer/AddInterfaces.java
@@ -311,14 +311,12 @@ class AddInterfaces extends SubstTransformer {
int ifaceMods = classDef.mods | INTERFACE_MODS;
ClassDef interfaceDef = (ClassDef)make.ClassDef(classDef.pos,
- ifaceMods,
- classDef.name,
+ ifaceSym,
classDef.tparams,
EMPTY_PARAMS,
classDef.tpe,
ifaceTmpl);
interfaceDef.setType(Type.NoType);
- interfaceDef.setSymbol(ifaceSym);
createdIFaces.add(ifaceSym);
@@ -360,13 +358,13 @@ class AddInterfaces extends SubstTransformer {
return copy.Apply(tree, fixClassSymbols(fun), args);
case TypeApply(Tree fun, Tree[] args):
return copy.TypeApply(tree, fixClassSymbols(fun), args);
- case Select(Tree qualifier, Name selector): {
+ case Select(Tree qualifier, _): {
Symbol classSym = getClassSym(tree.symbol());
- return copy.Select(tree, qualifier, classSym.name).setSymbol(classSym);
+ return copy.Select(tree, classSym, qualifier);
}
- case Ident(Name name): {
+ case Ident(_): {
Symbol classSym = getClassSym(tree.symbol());
- return copy.Ident(tree, classSym.name).setSymbol(classSym);
+ return copy.Ident(tree, classSym);
}
default:
throw global.fail("unexpected tree",tree);
@@ -403,8 +401,8 @@ class AddInterfaces extends SubstTransformer {
}
switch (tree) {
- case ClassDef(int mods,
- Name name,
+ case ClassDef(_,
+ _,
TypeDef[] tparams,
ValDef[][] vparams,
Tree tpe,
@@ -498,13 +496,11 @@ class AddInterfaces extends SubstTransformer {
Tree newTree =
copy.ClassDef(classDef,
- classSym.flags,
- classSym.name.toTypeName(),
+ classSym,
transform(tparams),
transform(vparams),
transform(tpe),
- newImpl)
- .setSymbol(classSym);
+ newImpl);
thisTypeSubst = thisTypeSubst.outer;
popSymbolSubst();
@@ -555,7 +551,7 @@ class AddInterfaces extends SubstTransformer {
return super.transform(tree);
}
- case Select(Super(_), Name selector): {
+ case Select(Super(_), _): {
// Use class member symbol for "super" references.
Symbol sym = tree.symbol();
if (needInterface(sym.classOwner())) {
diff --git a/sources/scalac/transformer/Erasure.java b/sources/scalac/transformer/Erasure.java
index 9500c8e5ca..e09189622f 100644
--- a/sources/scalac/transformer/Erasure.java
+++ b/sources/scalac/transformer/Erasure.java
@@ -327,30 +327,28 @@ public class Erasure extends Transformer implements Modifiers {
assert tree.type != null : tree;
Type owntype = eraseFully ? tree.type.fullErasure() : tree.type.erasure();
switch (tree) {
- case ClassDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):
+ case ClassDef(_, _, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):
Symbol oldCurrentClass = currentClass;
currentClass = tree.symbol();
Tree newTree =
- copy.ClassDef(tree, mods, name, new TypeDef[0],
+ copy.ClassDef(tree, new TypeDef[0],
transform(vparams), tpe, transform(impl, tree.symbol()))
.setType(owntype);
currentClass = oldCurrentClass;
return newTree;
- case DefDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):
+ case DefDef(_, _, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):
addBridges(tree.symbol());
Tree tpe1 = gen.mkType(tpe.pos, tpe.type.fullErasure());
Tree rhs1 = (rhs == Tree.Empty) ? rhs : transform(rhs, tpe1.type);
return copy.DefDef(
- tree, mods, name, new TypeDef[0], transform(vparams), tpe1, rhs1)
+ tree, new TypeDef[0], transform(vparams), tpe1, rhs1)
.setType(owntype);
- case ValDef(int mods, Name name, Tree tpe, Tree rhs):
+ case ValDef(_, _, Tree tpe, Tree rhs):
Tree tpe1 = transform(tpe);
Tree rhs1 = (rhs == Tree.Empty) ? rhs : transform(rhs, tpe1.type);
- return copy.ValDef(
- tree, mods, name, tpe1, rhs1)
- .setType(owntype);
+ return copy.ValDef(tree, tpe1, rhs1).setType(owntype);
case TypeDef(_, _, _):
// eliminate
@@ -537,12 +535,13 @@ public class Erasure extends Transformer implements Modifiers {
case Ident(_):
tree1 = tree;
break;
- case Select(Tree qual, Name name):
+ case Select(Tree qual, _):
+ Symbol sym = tree.symbol();
Tree qual1 = transform(qual);
if (isUnboxed(qual1.type))
- if (!isUnboxedArray(qual1.type) || tree.symbol() == definitions.ARRAY_CLASS)
+ if (!isUnboxedArray(qual1.type) || sym == definitions.ARRAY_CLASS)
qual1 = box(qual1);
- tree1 = copy.Select(tree, qual1, name);
+ tree1 = copy.Select(tree, sym, qual1);
break;
default:
throw Debug.abort("illegal case", tree);
diff --git a/sources/scalac/transformer/ExpandMixins.java b/sources/scalac/transformer/ExpandMixins.java
index 9959490afc..2de075bb62 100644
--- a/sources/scalac/transformer/ExpandMixins.java
+++ b/sources/scalac/transformer/ExpandMixins.java
@@ -316,24 +316,24 @@ public class ExpandMixins extends Transformer {
public Tree transform(Tree tree) {
switch (tree) {
- case ClassDef(int mods,
- Name name,
+ case ClassDef(_,
+ _,
TypeDef[] tparams,
ValDef[][] vparams,
Tree tpe,
Template impl):
- if (Modifiers.Helper.isInterface(mods))
+ Symbol sym = tree.symbol();
+ if (Modifiers.Helper.isInterface(sym.flags))
return super.transform(tree);
else {
- global.log("expanding " + name);
+ global.log("expanding " + sym);
Tree.ClassDef newClass = (Tree.ClassDef)
copy.ClassDef(tree,
- mods,
- name,
+ sym,
super.transform(tparams),
super.transform(vparams),
super.transform(tpe),
- getMixinExpandedTemplate(impl, tree.symbol()));
+ getMixinExpandedTemplate(impl, sym));
newClass.symbol().updateInfo(newClass.impl.type);
return newClass;
}
@@ -342,7 +342,7 @@ public class ExpandMixins extends Transformer {
Tree newTree = super.transform(tree);
switch (newTree) {
- case Apply(Select(Tree qualifier, Name selector), Tree[] args): {
+ case Apply(Select(Tree qualifier, _), Tree[] args): {
Tree fun = ((Tree.Apply)newTree).fun;
Symbol funOwnerSym = fun.symbol().owner();
Symbol qualSym = qualifier.type.symbol().moduleClass();
@@ -357,7 +357,7 @@ public class ExpandMixins extends Transformer {
}),
Tree.EMPTY_ARRAY);
return copy.Apply(newTree,
- copy.Select(fun, castQualifier, selector),
+ copy.Select(fun, castQualifier),
args);
} else
return newTree;
@@ -411,7 +411,7 @@ public class ExpandMixins extends Transformer {
return super.transform(tree);
}
- case Select(Super(Tree tpe), Name selector): {
+ case Select(Super(Tree tpe), _): {
Symbol sym = tree.symbol();
if (mixedInSymbols.containsKey(sym))
return gen.Ident((Symbol)mixedInSymbols.get(sym));
diff --git a/sources/scalac/transformer/ExplicitOuterClasses.java b/sources/scalac/transformer/ExplicitOuterClasses.java
index 283da9d24c..0cfd2a823b 100644
--- a/sources/scalac/transformer/ExplicitOuterClasses.java
+++ b/sources/scalac/transformer/ExplicitOuterClasses.java
@@ -99,12 +99,10 @@ public class ExplicitOuterClasses extends Transformer {
constSym.updateInfo(newConstType);
- int newMods = classDef.mods | Modifiers.STATIC;
classSym.flags |= Modifiers.STATIC;
return copy.ClassDef(classDef,
- newMods,
- classDef.name,
+ classSym,
transform(classDef.tparams),
transform(newVParams),
transform(classDef.tpe),
@@ -164,8 +162,8 @@ public class ExplicitOuterClasses extends Transformer {
return newTree;
}
- case Ident(Name name): {
- if (! name.isTermName())
+ case Ident(_): {
+ if (! tree.symbol().name.isTermName())
return super.transform(tree);
// Follow "outer" links to fetch data in outer classes.
@@ -204,17 +202,16 @@ public class ExplicitOuterClasses extends Transformer {
if (realFun.hasSymbol() && realFun.symbol().isPrimaryConstructor()) {
switch (transform(realFun)) {
- case Select(Tree qualifier, Name selector): {
+ case Select(Tree qualifier, _): {
if (! (qualifier.hasSymbol()
&& Modifiers.Helper.isNoVal(qualifier.symbol().flags))) {
- newFun = make.Ident(qualifier.pos, selector)
- .setType(realFun.type())
- .setSymbol(realFun.symbol());
+ newFun = make.Ident(qualifier.pos, realFun.symbol())
+ .setType(realFun.type());
newArg = qualifier;
}
} break;
- case Ident(Name name): {
+ case Ident(_): {
int level = outerLevel(realFun.symbol().owner());
if (level >= 0) {
newFun = realFun;
diff --git a/sources/scalac/transformer/LambdaLift.java b/sources/scalac/transformer/LambdaLift.java
index ad1940bb99..bee9f9b896 100644
--- a/sources/scalac/transformer/LambdaLift.java
+++ b/sources/scalac/transformer/LambdaLift.java
@@ -207,15 +207,15 @@ public class LambdaLift extends OwnerTransformer
}
return super.transform(tree);
- case TypeDef(int mods, Name name, Tree rhs):
+ case TypeDef(_, _, Tree rhs):
// ignore type definition as owner.
// reason: it might be in a refinement
// todo: handle type parameters?
return copy.TypeDef(
- tree, mods, name,
+ tree, sym,
transform(rhs, currentOwner));
- case Ident(Name name):
+ case Ident(_):
if (sym.isLocal()) {
if (sym.isMethod()) {
Symbol f = enclFun(currentOwner);
@@ -311,14 +311,14 @@ public class LambdaLift extends OwnerTransformer
//global.debugPrinter.print("lifting ").print(tree).println().end();//DEBUG
tree.type = descr.transform(tree.type, currentOwner);
switch (tree) {
- case ClassDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):
+ case ClassDef(_, _, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):
Symbol sym = tree.symbol();
if (sym.isLocal()) {
Symbol[] newtparams = ftvsParams(sym.constructor());
Symbol[] newparams = fvsParams(sym.constructor());
liftSymbol(sym, newtparams, newparams);
Tree tree1 = copy.ClassDef(
- tree, mods, sym.name,
+ tree, sym,
addTypeParams(transform(tparams, sym), newtparams),
new ValDef[][]{addParams(transform(vparams, sym)[0], newparams)},
transform(tpe, sym),
@@ -327,19 +327,19 @@ public class LambdaLift extends OwnerTransformer
return Tree.Empty;
} else {
return copy.ClassDef(
- tree, mods, sym.name,
+ tree, sym,
transform(tparams, sym), transform(vparams, sym), transform(tpe, sym),
transform(impl, sym));
}
- case DefDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):
+ case DefDef(_, _, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):
Symbol sym = tree.symbol();
if (sym.isLocal()) {
Symbol[] newtparams = ftvsParams(sym);
Symbol[] newparams = fvsParams(sym);
liftSymbol(sym, newtparams, newparams);
Tree tree1 = copy.DefDef(
- tree, mods, sym.name,
+ tree, sym,
addTypeParams(transform(tparams, sym), newtparams),
new ValDef[][]{addParams(transform(vparams, sym)[0], newparams)},
transform(tpe, sym),
@@ -348,22 +348,20 @@ public class LambdaLift extends OwnerTransformer
return Tree.Empty;
} else {
return copy.DefDef(
- tree, mods, sym.name,
+ tree, sym,
transform(tparams, sym), transform(vparams, sym), transform(tpe, sym),
transform(rhs, sym));
}
- case TypeDef(int mods, Name name, Tree rhs):
+ case TypeDef(_, _, Tree rhs):
// ignore type definition as owner.
// reason: it might be in a refinement
// todo: handle type parameters?
return copy.TypeDef(
- tree, mods, name,
- transform(rhs, currentOwner));
+ tree, tree.symbol(), transform(rhs, currentOwner));
- case ValDef(int mods, Name name, Tree tpe, Tree rhs):
+ case ValDef(_, _, Tree tpe, Tree rhs):
Symbol sym = tree.symbol();
- Name name1 = sym.name;
Tree tpe1 = transform(tpe);
Tree rhs1 = transform(rhs, sym);
if ((sym.flags & CAPTURED) != 0) {
@@ -378,7 +376,7 @@ public class LambdaLift extends OwnerTransformer
new Type[]{unboxedType},
new Tree[]{rhs1});
}
- return copy.ValDef(tree, mods, name1, tpe1, rhs1);
+ return copy.ValDef(tree, sym, tpe1, rhs1);
case Tuple(Tree[] args):
Tree tree1 = mkList(tree.pos, tree.type, transform(args));
@@ -402,14 +400,13 @@ public class LambdaLift extends OwnerTransformer
return copy.Apply(
tree, fn1, addFreeArgs(tree.pos, get(free.fvs, fsym), args1));
- case Ident(Name name):
+ case Ident(_):
Symbol sym = tree.symbol();
- Name name1 = sym.name;
if (sym.isLocal() &&
(sym.kind == TYPE || (sym.kind == VAL && !sym.isMethod()))) {
sym = descr.proxy(sym, currentOwner);
}
- Tree tree1 = copy.Ident(tree, name1).setSymbol(sym).setType(
+ Tree tree1 = copy.Ident(tree, sym).setType(
sym.typeAt(descr.nextPhase));
if ((sym.flags & CAPTURED) != 0) return gen.Select(tree1, Names.elem);
else return tree1;
diff --git a/sources/scalac/transformer/OwnerTransformer.java b/sources/scalac/transformer/OwnerTransformer.java
index 0ac1c2abac..51711ed2da 100644
--- a/sources/scalac/transformer/OwnerTransformer.java
+++ b/sources/scalac/transformer/OwnerTransformer.java
@@ -91,37 +91,47 @@ public class OwnerTransformer extends Transformer {
switch(tree) {
case PackageDef(Tree packaged, Template impl):
return copy.PackageDef(
- tree, transform(packaged), transform(impl, packaged.symbol()));
+ tree,
+ transform(packaged),
+ transform(impl, packaged.symbol()));
- case ClassDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):
+ case ClassDef(_, _, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):
+ Symbol symbol = tree.symbol();
return copy.ClassDef(
- tree, mods, name,
- transform(tparams, tree.symbol().constructor()),
- transform(vparams, tree.symbol().constructor()),
+ tree, symbol,
+ transform(tparams, symbol.constructor()),
+ transform(vparams, symbol.constructor()),
transform(tpe),
- transform(impl, tree.symbol()));
+ transform(impl, symbol));
- case ModuleDef(int mods, Name name, Tree tpe, Template impl):
+ case ModuleDef(_, _, Tree tpe, Template impl):
+ Symbol symbol = tree.symbol();
return copy.ModuleDef(
- tree, mods, name, transform(tpe),
- transform(impl, tree.symbol().moduleClass()));
+ tree, symbol,
+ transform(tpe),
+ transform(impl, symbol.moduleClass()));
- case DefDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):
+ case DefDef(_, _, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):
+ Symbol symbol = tree.symbol();
return copy.DefDef(
- tree, mods, name,
- transform(tparams, tree.symbol()),
- transform(vparams, tree.symbol()),
- transform(tpe, tree.symbol()),
- transform(rhs, tree.symbol()));
-
- case ValDef(int mods, Name name, Tree tpe, Tree rhs):
+ tree, symbol,
+ transform(tparams, symbol),
+ transform(vparams, symbol),
+ transform(tpe, symbol),
+ transform(rhs, symbol));
+
+ case ValDef(_, _, Tree tpe, Tree rhs):
+ Symbol symbol = tree.symbol();
return copy.ValDef(
- tree, mods, name, transform(tpe),
- transform(rhs, tree.symbol()));
+ tree, symbol,
+ transform(tpe),
+ transform(rhs, symbol));
- case TypeDef(int mods, Name name, Tree rhs):
+ case TypeDef(_, _, Tree rhs):
+ Symbol symbol = tree.symbol();
return copy.TypeDef(
- tree, mods, name, transform(rhs, tree.symbol()));
+ tree, symbol,
+ transform(rhs, symbol));
default:
return super.transform(tree);
diff --git a/sources/scalac/transformer/UnCurry.java b/sources/scalac/transformer/UnCurry.java
index aba9ef8966..6ac4165914 100644
--- a/sources/scalac/transformer/UnCurry.java
+++ b/sources/scalac/transformer/UnCurry.java
@@ -72,26 +72,25 @@ public class UnCurry extends OwnerTransformer
//uncurry type and symbol
if (tree.type != null) tree.type = descr.uncurry(tree.type);
switch (tree) {
- case ClassDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):
+ case ClassDef(_, _, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):
return copy.ClassDef(
- tree, mods, name, tparams,
+ tree, tree.symbol(), tparams,
uncurry(transform(vparams, tree.symbol())),
tpe,
transform(impl, tree.symbol()));
- case DefDef(int mods, Name name, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):
+ case DefDef(_, _, TypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):
Tree rhs1 = transform(rhs, tree.symbol());
return copy.DefDef(
- tree, mods, name, tparams,
+ tree, tree.symbol(), tparams,
uncurry(transform(vparams, tree.symbol())),
tpe, rhs1);
- case ValDef(int mods, Name name, Tree tpe, Tree rhs):
+ case ValDef(_, _, Tree tpe, Tree rhs):
if (tree.symbol().isDefParameter()) {
- int mods1 = mods & ~ DEF;
Type newtype = global.definitions.functionType(Type.EMPTY_ARRAY, tpe.type);
Tree tpe1 = gen.mkType(tpe.pos, newtype);
- return copy.ValDef(tree, mods1, name, tpe1, rhs).setType(newtype);
+ return copy.ValDef(tree, tpe1, rhs).setType(newtype);
} else {
return super.transform(tree);
}
diff --git a/sources/scalac/typechecker/Analyzer.java b/sources/scalac/typechecker/Analyzer.java
index acd08e91e5..4292e3b101 100644
--- a/sources/scalac/typechecker/Analyzer.java
+++ b/sources/scalac/typechecker/Analyzer.java
@@ -681,9 +681,8 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
.setType(tree.symbol().type());
case Select(Tree qual, Name name):
Tree qual1 = transformPackageId(qual);
- return copy.Select(tree, qual1, name)
- .setSymbol(packageSymbol(tree.pos, qual1.symbol(), name))
- .setType(tree.symbol().type());
+ Symbol sym = packageSymbol(tree.pos, qual1.symbol(), name);
+ return copy.Select(tree, sym, qual1).setType(sym.type());
default:
return transform(tree);
}
@@ -1233,8 +1232,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
//System.out.println(qual.type + ".member: " + sym + ":" + symtype);//DEBUG
switch (tree) {
case Select(_, _):
- return copy.Select(tree, qual, name)
- .setSymbol(sym).setType(symtype);
+ return copy.Select(tree, sym, qual).setType(symtype);
case SelectFromType(_, _):
return make.TypeTerm(tree.pos).setType(symtype);
default:
@@ -1671,23 +1669,23 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
// convert nullary case methods to types
// check that other idents or selects are stable.
switch (tree) {
- case Ident(Name name):
+ case Ident(_):
if (sym != null && isNullaryMethod(sym) && (sym.flags & CASE) != 0)
return transform(
make.Apply(
tree.pos,
- copy.Ident(tree, name).setSymbol(sym.type().resultType().symbol()),
+ copy.Ident(tree, sym.type().resultType().symbol()),
Tree.EMPTY_ARRAY),
mode, pt);
else
checkStable(tree);
break;
- case Select(Tree qual, Name name):
+ case Select(Tree qual, _):
if (sym != null && isNullaryMethod(sym) && (sym.flags & CASE) != 0)
return transform(
make.Apply(
tree.pos,
- copy.Select(tree, qual, name).setSymbol(sym.type().resultType().symbol()),
+ copy.Select(tree, sym.type().resultType().symbol(), qual),
Tree.EMPTY_ARRAY),
mode, pt);
else
@@ -1823,7 +1821,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
}
return tree.setType(Type.ErrorType);
- case ClassDef(int mods, Name name, Tree.TypeDef[] tparams, Tree.ValDef[][] vparams, Tree tpe, Tree.Template templ):
+ case ClassDef(_, _, Tree.TypeDef[] tparams, Tree.ValDef[][] vparams, Tree tpe, Tree.Template templ):
pushContext(tree, sym.constructor(), new Scope(context.scope));
reenterParams(tparams);
Tree.TypeDef[] tparams1 = transform(tparams);
@@ -1832,23 +1830,23 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
Tree tpe1 = transform(tpe);
Tree.Template templ1 = transformTemplate(templ, sym);
popContext();
- return copy.ClassDef(tree, mods, name, tparams1, vparams1, tpe1, templ1)
+ return copy.ClassDef(tree, sym, tparams1, vparams1, tpe1, templ1)
.setType(definitions.UNIT_TYPE);
- case ModuleDef(int mods, Name name, Tree tpe, Tree.Template templ):
+ case ModuleDef(_, _, Tree tpe, Tree.Template templ):
Tree tpe1 = transform(tpe, TYPEmode);
Tree.Template templ1 = transformTemplate(templ, sym.moduleClass());
- return copy.ModuleDef(tree, mods, name, tpe1, templ1)
+ return copy.ModuleDef(tree, sym, tpe1, templ1)
.setType(definitions.UNIT_TYPE);
- case ValDef(int mods, Name name, Tree tpe, Tree rhs):
+ case ValDef(_, _, Tree tpe, Tree rhs):
Tree tpe1 = transform(tpe, TYPEmode);
Tree rhs1 = rhs;
if (tpe1 == Tree.Empty) {
tpe1 = gen.mkType(rhs.pos, rhs.type);
// rhs already attributed by defineSym in this case
} else if (rhs != Tree.Empty) {
- if ((mods & CASEACCESSOR) != 0) {
+ if ((sym.flags & CASEACCESSOR) != 0) {
//rhs was already attribute
} else {
pushContext(tree, sym, context.scope);
@@ -1856,10 +1854,10 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
popContext();
}
}
- return copy.ValDef(tree, mods, name, tpe1, rhs1)
+ return copy.ValDef(tree, sym, tpe1, rhs1)
.setType(definitions.UNIT_TYPE);
- case DefDef(int mods, Name name, Tree.TypeDef[] tparams, Tree.ValDef[][] vparams, Tree tpe, Tree rhs):
+ case DefDef(_, _, Tree.TypeDef[] tparams, Tree.ValDef[][] vparams, Tree tpe, Tree rhs):
pushContext(tree, sym, new Scope(context.scope));
reenterParams(tparams);
Tree.TypeDef[] tparams1 = transform(tparams);
@@ -1876,16 +1874,16 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
tpe1.type == Type.NoType ? Type.AnyType : tpe1.type);
}
popContext();
- return copy.DefDef(tree, mods, name, tparams1, vparams1, tpe1, rhs1)
+ return copy.DefDef(tree, sym, tparams1, vparams1, tpe1, rhs1)
.setType(definitions.UNIT_TYPE);
- case TypeDef(int mods, Name name, Tree rhs):
+ case TypeDef(_, _, Tree rhs):
pushContext(tree, sym, new Scope(context.scope));
int mode = TYPEmode;
if (sym.kind == ALIAS) mode |= FUNmode;
Tree rhs1 = transform(rhs, mode);
popContext();
- return copy.TypeDef(tree, mods, name, rhs1)
+ return copy.TypeDef(tree, sym, rhs1)
.setType(definitions.UNIT_TYPE);
case Import(Tree expr, Name[] selectors):
@@ -1969,8 +1967,8 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
if (parents.length == 1 && body.length == 0) {
Tree parent1 = transform(parents[0], CONSTRmode, pt);
Tree.Template templ1 = (Tree.Template)
- copy.Template(templ, new Tree[]{parent1}, body)
- .setType(parent1.type).setSymbol(Symbol.NONE);
+ copy.Template(templ, Symbol.NONE, new Tree[]{parent1}, body)
+ .setType(parent1.type);
Type owntype = parent1.type;
checkInstantiatable(tree.pos, owntype);
return copy.New(tree, templ1)
diff --git a/sources/scalac/typechecker/DeSugarize.java b/sources/scalac/typechecker/DeSugarize.java
index 508f797b11..13e9ad4564 100644
--- a/sources/scalac/typechecker/DeSugarize.java
+++ b/sources/scalac/typechecker/DeSugarize.java
@@ -614,8 +614,8 @@ public class DeSugarize implements Kinds, Modifiers {
case Ident(_):
return tree;
- case Select(Tree qual, Name name):
- return copy.Select(tree, liftout(qual, defs), name);
+ case Select(Tree qual, _):
+ return copy.Select(tree, liftout(qual, defs));
case TypeApply(Tree fn, Tree[] args):
return copy.TypeApply(tree, liftoutPrefix(fn, defs), args);
diff --git a/sources/scalac/typechecker/RefCheck.java b/sources/scalac/typechecker/RefCheck.java
index 53258e5dd1..2728bdb6c3 100644
--- a/sources/scalac/typechecker/RefCheck.java
+++ b/sources/scalac/typechecker/RefCheck.java
@@ -412,12 +412,12 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
case TypeApply(Tree fn, Tree[] args):
return toMethodType(
copy.TypeApply(tree, toConstructor1(fn, constr), args));
- case Ident(Name name):
+ case Ident(_):
return toMethodType(
- copy.Ident(tree, constr.name).setSymbol(constr));
- case Select(Tree qual, Name name):
+ copy.Ident(tree, constr));
+ case Select(Tree qual, _):
return toMethodType(
- copy.Select(tree, qual, constr.name).setSymbol(constr));
+ copy.Select(tree, constr, qual));
default:
throw new ApplicationError();
}
@@ -473,9 +473,9 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
public Tree transform(Tree tree) {
Tree tree1;
switch (tree) {
- case ClassDef(int mods, Name name, Tree.TypeDef[] tparams, Tree.ValDef[][] vparams, Tree tpe, Tree.Template templ):
+ case ClassDef(_, _, Tree.TypeDef[] tparams, Tree.ValDef[][] vparams, Tree tpe, Tree.Template templ):
return super.transform(
- copy.ClassDef(tree, mods, name, tparams, vparams, tpe, addCaseMethods(templ, tree.symbol())));
+ copy.ClassDef(tree, tree.symbol(), tparams, vparams, tpe, addCaseMethods(templ, tree.symbol())));
case Template(Tree[] bases, Tree[] body):
Tree[] bases1 = transform(bases);
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-01 16:03:39 +0000