- Changed Tree.New(Template) to Tree.New(Tree)

9 files changed, 64 insertions, 78 deletions

diff --git a/sources/scalac/ast/Transformer.java.tmpl b/sources/scalac/ast/Transformer.java.tmpl
index 1af073fc86..2c8d355587 100644
--- a/sources/scalac/ast/Transformer.java.tmpl
+++ b/sources/scalac/ast/Transformer.java.tmpl
@@ -236,9 +236,8 @@ public class GenTransformer {
 
         // case Throw(Tree expr):
 
-        case New(Template(Tree[] base, Tree[] body)):
-            assert base.length == 1 && body.length == 0: tree;
-            return gen.New(tree.pos, transform(base[0]));
+        case New(Tree init):
+            return gen.New(tree.pos, transform(init));
 
         case Typed(Tree expr, Tree tpe):
             return gen.Typed(tree.pos, transform(expr), transform(tpe));
diff --git a/sources/scalac/ast/TreeGen.java b/sources/scalac/ast/TreeGen.java
index 20b3cab3c4..6cf6c6cb23 100644
--- a/sources/scalac/ast/TreeGen.java
+++ b/sources/scalac/ast/TreeGen.java
@@ -458,6 +458,33 @@ public class TreeGen implements Kinds, Modifiers, TypeTags {
     }
 
     //########################################################################
+    // Public Methods - Building new instances
+
+    /** Builds a New node corresponding to "new <init>". */
+    public New New(int pos, Tree init) {
+	New tree = make.New(pos, init);
+        tree.setType(init.type);
+        // after AddConstructor use type of symbol
+        switch (init) {
+        case Apply(TypeApply(Tree fun, Tree[] targs), _):
+            Symbol sym = fun.symbol();
+            if (sym == null || sym.isConstructor()) break;
+            Type[] args = Tree.typeOf(targs);
+            tree.setType(Type.appliedType(sym.owner().nextType(), args));
+            break;
+        case Apply(Tree fun, _):
+            Symbol sym = fun.symbol();
+            if (sym == null || sym.isConstructor()) break;
+            tree.setType(sym.owner().nextType());
+            break;
+        }
+        return tree;
+    }
+    public New New(Tree init) {
+        return New(init.pos, init);
+    }
+
+    //########################################################################
     // Public Methods - Building expressions - Simple nodes
 
     /** Flattens the given tree array by inlining Block nodes. */
@@ -690,32 +717,6 @@ public class TreeGen implements Kinds, Modifiers, TypeTags {
         return Return(value.pos, method, value);
     }
 
-    /** Builds a New node corresponding to "new <constr>". */
-    public Tree New(int pos, Tree constr) {
-        Tree[] constrs = { constr };
-	Template templ = Template(pos, Symbol.NONE, constrs, Tree.EMPTY_ARRAY);
-	New tree = make.New(pos, templ);
-        tree.setType(constr.type);
-        // after AddConstructor use type of symbol
-        switch (constr) {
-        case Apply(TypeApply(Tree fun, Tree[] targs), _):
-            Symbol sym = fun.symbol();
-            if (sym == null || sym.isConstructor()) break;
-            Type[] args = Tree.typeOf(targs);
-            tree.setType(Type.appliedType(sym.owner().nextType(), args));
-            break;
-        case Apply(Tree fun, _):
-            Symbol sym = fun.symbol();
-            if (sym == null || sym.isConstructor()) break;
-            tree.setType(sym.owner().nextType());
-            break;
-        }
-        return tree;
-    }
-    public Tree New(Tree constr) {
-        return New(constr.pos, constr);
-    }
-
     /** Builds a Typed nodes with given value and type. */
     public Typed Typed(int pos, Tree value, Tree type) {
         Typed tree = make.Typed(pos, value, type);
@@ -1130,9 +1131,8 @@ public class TreeGen implements Kinds, Modifiers, TypeTags {
 	changeOwner(body, owner, applyMeth);
         Tree[] memberTrees = { DefDef(applyMeth, body) };
         Tree classDef = ClassDef(clazz, memberTrees);
-	Tree alloc = New(mkApply__(mkPrimaryConstructorLocalRef(pos, clazz)))
-            .setType(parentTypes[1]); // !!!
-	return mkBlock(classDef, alloc);
+	Tree alloc = New(mkApply__(mkPrimaryConstructorLocalRef(pos, clazz)));
+	return mkBlock(classDef, Typed(alloc, parentTypes[1])); // !!! Typed
     }
 
 
@@ -1151,9 +1151,8 @@ public class TreeGen implements Kinds, Modifiers, TypeTags {
             makeVisitorMethod(pos, Names.isDefinedAt, isDefinedAtVisitor,
                               pattype, definitions.BOOLEAN_TYPE(), clazz, owner)};
         Tree classDef = ClassDef(clazz, memberTrees);
-	Tree alloc = New(mkApply__(mkPrimaryConstructorLocalRef(pos, clazz)))
-	    .setType(parentTypes[1]); // !!!
-	return mkBlock(classDef, alloc);
+	Tree alloc = New(mkApply__(mkPrimaryConstructorLocalRef(pos, clazz)));
+	return mkBlock(classDef, Typed(alloc, parentTypes[1])); // !!! Typed
     }
     //where
 	private Tree makeVisitorMethod(int pos, Name name, Tree visitor,
diff --git a/sources/scalac/atree/ATreeFromSTree.java b/sources/scalac/atree/ATreeFromSTree.java
index e886ece922..c092280d70 100644
--- a/sources/scalac/atree/ATreeFromSTree.java
+++ b/sources/scalac/atree/ATreeFromSTree.java
@@ -227,8 +227,8 @@ public class ATreeFromSTree {
         case Throw(Tree value):
             return make.Throw(tree, expression(value));
 
-        case New(Template(Tree[] bases, _)):
-            return expression(bases[0]);
+        case New(Tree init):
+            return expression(init);
 
         case Apply(TypeApply(Tree fun, Tree[] targs), Tree[] vargs):
             return apply(tree, fun, targs, vargs);
diff --git a/sources/scalac/backend/jvm/GenJVM.java b/sources/scalac/backend/jvm/GenJVM.java
index f16ce8d85b..1804581884 100644
--- a/sources/scalac/backend/jvm/GenJVM.java
+++ b/sources/scalac/backend/jvm/GenJVM.java
@@ -267,16 +267,13 @@ class GenJVM {
             generatedType = expectedType;
             break;
 
-        case New(Tree.Template templ): {
-            assert templ.body.length == 0;
-            assert templ.parents.length == 1;
-
+        case New(Tree init):
             String className = javaName(tree.type.symbol());
             ctx.code.emitNEW(className);
             ctx.code.emitDUP();
-            gen(ctx, templ.parents[0]);
+            gen(ctx, init);
             generatedType = new JObjectType(className);
-        } break;
+            break;
 
         case Apply(TypeApply(Tree fun, Tree[] args), _): {
             genLoadQualifier(ctx, fun);
diff --git a/sources/scalac/backend/msil/GenMSIL.java b/sources/scalac/backend/msil/GenMSIL.java
index 82002c6a41..419bc03e0d 100644
--- a/sources/scalac/backend/msil/GenMSIL.java
+++ b/sources/scalac/backend/msil/GenMSIL.java
@@ -569,17 +569,15 @@ public final class GenMSIL {
 	    lastExpr = tmpLastExpr;
 	    return check(store(var));
 
-	case New(Template(Tree[] baseClasses, Tree[] body)):
-	    assert body.length == 0 : "Template should not have a body!";
-	    switch (baseClasses[0]) {
+	case New(Tree init):
+	    switch (init) {
 	    case Apply(Tree fun, Tree[] args):
 		ConstructorInfo ctor = (ConstructorInfo) tc.getMethod(fun.symbol());
 		loadArgs(args, ctor.GetParameters());
 		code.Emit(OpCodes.Newobj, ctor);
 		return coerce(items.StackItem(msilType(ctor.DeclaringType)), toType);
 	    default:
-		throw new ApplicationError("Incorrect tree: "
-					   + baseClasses[0].getClass());
+		throw Debug.abort("Incorrect tree", init);
 	    }
 
 	case This(_):
diff --git a/sources/scalac/checkers/TreeChecker.java b/sources/scalac/checkers/TreeChecker.java
index 4878873b51..6e15c8cbfb 100644
--- a/sources/scalac/checkers/TreeChecker.java
+++ b/sources/scalac/checkers/TreeChecker.java
@@ -263,14 +263,13 @@ public class TreeChecker {
         case Throw(Tree value):
             return expression(value, definitions.THROWABLE_TYPE());
 
-        case New(Template(Tree[] bases, Tree[] body)):
-            assert bases.length == 1 && body.length == 0: show(tree);
-            Tree fun = TreeInfo.methPart(bases[0]);
+        case New(Tree init):
+            Tree fun = TreeInfo.methPart(init);
             assert fun instanceof Tree.Ident: show(tree);
             Symbol symbol = fun.symbol();
             assert symbol != null && !symbol.isLabel(): show(tree);
             assert symbol.isInitializer(): show(tree);
-            return expression(bases[0], definitions.UNIT_TYPE());
+            return expression(init, definitions.UNIT_TYPE());
 
         case Apply(Tree vfun, Tree[] vargs):
             vapply(tree, vfun.type(), vargs);
diff --git a/sources/scalac/transformer/AddConstructors.java b/sources/scalac/transformer/AddConstructors.java
index 79400cf6d1..d592f83be7 100644
--- a/sources/scalac/transformer/AddConstructors.java
+++ b/sources/scalac/transformer/AddConstructors.java
@@ -217,8 +217,8 @@ public class AddConstructors extends GenTransformer {
                     tree.symbol().setOwner(primaryInitializer);
             return super.transform(tree);
 
-        case New(Template(Tree[] parents, _)):
-            return gen.New(transform(parents[0], true));
+        case New(Tree init):
+            return gen.New(transform(init, true));
 
  	case TypeApply(Tree fun, Tree[] args):
             if (!inNew && fun.symbol().isConstructor()) return transform(fun);
diff --git a/sources/scalac/transformer/Erasure.java b/sources/scalac/transformer/Erasure.java
index f142f6f623..430c157b0e 100644
--- a/sources/scalac/transformer/Erasure.java
+++ b/sources/scalac/transformer/Erasure.java
@@ -143,10 +143,9 @@ public class Erasure extends GenTransformer implements Modifiers {
             Type type = method.nextType().resultType();
 	    return gen.Return(tree.pos, method, transform(expr, type));
 
-        case New(Template(Tree[] base, Tree[] body)):
-            assert base.length == 1 && body.length == 0: tree;
+        case New(Tree init):
             if (tree.getType().symbol() == definitions.ARRAY_CLASS) {
-                switch (base[0]) {
+                switch (init) {
                 case Apply(_, Tree[] args):
                     assert args.length == 1: tree;
                     Type element = getArrayElementType(tree.getType()).erasure();
@@ -156,7 +155,7 @@ public class Erasure extends GenTransformer implements Modifiers {
                     throw Debug.abort("illegal case", tree);
                 }
             }
-	    return gen.New(tree.pos, transform(base[0]));
+	    return gen.New(tree.pos, transform(init));
 
 	case Apply(TypeApply(Tree fun, Tree[] targs), Tree[] vargs):
             fun = transform(fun);
diff --git a/sources/scalac/transformer/TypesAsValuesPhase.java b/sources/scalac/transformer/TypesAsValuesPhase.java
index d4d194bbc6..103234b984 100644
--- a/sources/scalac/transformer/TypesAsValuesPhase.java
+++ b/sources/scalac/transformer/TypesAsValuesPhase.java
@@ -265,27 +265,22 @@ public class TypesAsValuesPhase extends Phase {
                 Symbol symbol = getSymbolFor(tree);
                 return gen.ValDef(symbol, transform(rhs, symbol));
 
-            case New(Tree.Template(Tree[] parents, Tree[] body)):
-                switch (parents[0]) {
-                case Apply(TypeApply(Tree fun, Tree[] targs), Tree[] vargs):
-                    if (fun.symbol() == ARRAY_CONSTRUCTOR) {
-                        // Transform array creations:
-                        //   new Array[T](size)
-                        // becomes
-                        //   asValue(T).newArray[T](size)
-                        assert targs.length == 1;
-                        assert vargs.length == 1;
-                        Tree newArrayfun = gen.mkRef(tree.pos,
-                                                     typeAsValue(targs[0].pos,
-                                                                 targs[0].type,
-                                                                 currentOwner),
-                                                     defs.TYPE_NEWARRAY());
-                        return gen.mkApplyTV(newArrayfun, targs, vargs);
-                    } else
-                        return super.transform(tree);
-                default:
+            case New(Apply(TypeApply(Tree fun, Tree[] targs), Tree[] vargs)):
+                if (fun.symbol() == ARRAY_CONSTRUCTOR) {
+                    // Transform array creations:
+                    //   new Array[T](size)
+                    // becomes
+                    //   asValue(T).newArray[T](size)
+                    assert targs.length == 1;
+                    assert vargs.length == 1;
+                    Tree newArrayfun = gen.mkRef(tree.pos,
+                                                 typeAsValue(targs[0].pos,
+                                                             targs[0].type,
+                                                             currentOwner),
+                                                 defs.TYPE_NEWARRAY());
+                    return gen.mkApplyTV(newArrayfun, targs, vargs);
+                } else
                     return super.transform(tree);
-                }
 
             case Apply(TypeApply(Tree fun, Tree[] targs), Tree[] vargs):
                 Symbol funSym = fun.symbol();