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

15 files changed, 128 insertions, 160 deletions

diff --git a/sources/meta/scalac/ast/Tree.java b/sources/meta/scalac/ast/Tree.java
index f8a130b52f..98cdc00414 100644
--- a/sources/meta/scalac/ast/Tree.java
+++ b/sources/meta/scalac/ast/Tree.java
@@ -299,7 +299,7 @@ public class Tree {
         n_New.
             setDescription("Instantiation").
             setRange(Phase.PARSER, Phase.END).
-            addField(n_Template.getType(0), "templ");
+            addField(t_TermTree, "init");
 
         n_Typed.
             setDescription("Type annotation").
diff --git a/sources/scala/tools/scalac/ast/parser/MarkupParser.scala b/sources/scala/tools/scalac/ast/parser/MarkupParser.scala
index f12ae9f68b..d879491cac 100644
--- a/sources/scala/tools/scalac/ast/parser/MarkupParser.scala
+++ b/sources/scala/tools/scalac/ast/parser/MarkupParser.scala
@@ -117,10 +117,7 @@ class MarkupParser( unit:Unit, s:Scanner, p:Parser ) {
                             _scala_xml_EntityRef( pos ),
                             Predef.Array[Tree]( gen.mkStringLit( pos, n.toString() )));
 
-    make.New( pos,
-             make.Template( pos,
-                           Predef.Array[Tree] ( constr ),
-                           Tree.EMPTY_ARRAY ));
+    make.New( pos, constr );
   };
   // create scala.xml.Text here <: scala.xml.Node
   def makeText( pos: int, txt:String ):Tree =
@@ -130,10 +127,7 @@ class MarkupParser( unit:Unit, s:Scanner, p:Parser ) {
     val constr = make.Apply( pos,
                            _scala_xml_Text( pos ),
                            Predef.Array[Tree] ( txt ));
-    make.New( pos,
-             make.Template( pos,
-                            Predef.Array[Tree] ( constr ),
-                            Tree.EMPTY_ARRAY ));
+    make.New( pos, constr );
   }
 
   def makeXMLpat(pos:int, n:Name, args:Array[Tree]):Tree =
@@ -170,10 +164,7 @@ class MarkupParser( unit:Unit, s:Scanner, p:Parser ) {
     val n = p.fresh();
     val nIdent = make.Ident(pos, n);
     blocArr( 0 ) = make.ValDef(pos, Modifiers.MUTABLE, n, Tree.Empty,
-                               make.New( pos,
-                                        make.Template( pos,
-                                                      Predef.Array[Tree] ( constr ),
-                                                      Tree.EMPTY_ARRAY )));
+                               make.New( pos, constr ));
 
     var i = 0; while( i < args.length ) {
       val ipos = args(i).pos;
diff --git a/sources/scala/tools/scalac/ast/parser/Parser.scala b/sources/scala/tools/scalac/ast/parser/Parser.scala
index d389c0f909..59fa4cf0fe 100644
--- a/sources/scala/tools/scalac/ast/parser/Parser.scala
+++ b/sources/scala/tools/scalac/ast/parser/Parser.scala
@@ -1012,7 +1012,26 @@ class Parser(unit: Unit) {
       case LBRACE =>
         t = blockExpr();
       case NEW =>
-        t = make.New(s.skipToken(), template());
+        val pos = s.skipToken();
+        val templ = template();
+        if (templ.parents.length == 1 && templ.body.length == 0) {
+          t = make.New(pos, templ.parents(0));
+        } else {
+          // flags == SYNTHETIC and name = ANON indicate an anonymous class
+          val flags = Modifiers.SYNTHETIC;
+          val name = Names.ANON_CLASS_NAME.toTypeName();
+	  val cd: Tree = make.ClassDef(
+		  templ.pos,
+                  flags,
+		  name,
+		  Tree.AbsTypeDef_EMPTY_ARRAY,
+		  NewArray.ValDefArray(Tree.ValDef_EMPTY_ARRAY),
+		  Tree.Empty,
+		  templ);
+          t = make.Block(
+            pos, Predef.Array[Tree](cd), make.New(
+              pos, make.Apply(pos, make.Ident(pos, name), Tree.EMPTY_ARRAY)));
+        }
       case _ =>
         return syntaxError("illegal start of expression", true);
     }
diff --git a/sources/scala/tools/scalac/ast/printer/TextTreePrinter.scala b/sources/scala/tools/scalac/ast/printer/TextTreePrinter.scala
index 75312d5f2e..b4ca7f1000 100644
--- a/sources/scala/tools/scalac/ast/printer/TextTreePrinter.scala
+++ b/sources/scala/tools/scalac/ast/printer/TextTreePrinter.scala
@@ -422,8 +422,10 @@ class TextTreePrinter(writer: PrintWriter) with TreePrinter {
 	print(Space);
 	print(expr);
 
-      case Tree$New(templ) =>
-	printTemplate(null, KW_NEW, templ, false);
+      case Tree$New(init) =>
+        print(KW_NEW);
+	print(Space);
+	print(init);
 	printType(tree);
 
       case Tree$Typed(expr, tpe) =>
diff --git a/sources/scala/tools/scalac/typechecker/Analyzer.scala b/sources/scala/tools/scalac/typechecker/Analyzer.scala
index 95cf3f1140..f610a5deb0 100644
--- a/sources/scala/tools/scalac/typechecker/Analyzer.scala
+++ b/sources/scala/tools/scalac/typechecker/Analyzer.scala
@@ -847,7 +847,11 @@ class Analyzer(global: scalac_Global, descr: AnalyzerPhase) extends Transformer(
         sym
 
       case Tree$ClassDef(mods, name, tparams, vparams, _, templ) =>
-	val clazz = classSymbol(tree.pos, name, owner, mods, context.scope);
+	val clazz =
+          if (mods == SYNTHETIC && name == Names.ANON_CLASS_NAME.toTypeName())
+            context.owner.newAnonymousClass(templ.pos)
+          else
+            classSymbol(tree.pos, name, owner, mods, context.scope);
 	if (!clazz.primaryConstructor().isInitialized())
 	  clazz.primaryConstructor().setInfo(new LazyTreeType(tree));
 	if ((mods & CASE) != 0) {
@@ -2301,67 +2305,35 @@ class Analyzer(global: scalac_Global, descr: AnalyzerPhase) extends Transformer(
 	    }
 	  }
 
-	case Tree$New(templ) =>
-	  templ match {
-	    case Tree$Template(parents, body) =>
-	      if (parents.length == 1 && body.length == 0) {
-		val parent1: Tree = transform(parents(0), CONSTRmode, pt);
-		val owntype: Type = parent1.getType();
-		val templ1: Tree$Template =
-		  copy.Template(templ, Symbol.NONE, NewArray.Tree(parent1), body)
-		  .setType(owntype).asInstanceOf[Tree$Template];
-		checkInstantiatable(tree.pos, owntype);
-		copy.New(tree, templ1)
-		  .setType(owntype.instanceType());
-	      } else {
-		pushContext(tree, context.owner, new Scope(context.scope));
-                val clazz: Symbol = context.owner.newAnonymousClass(templ.pos);
-		val cd: Tree = make.ClassDef(
-		  templ.pos,
-		  clazz,
-		  Tree.AbsTypeDef_EMPTY_ARRAY,
-		  NewArray.ValDefArray(Tree.ValDef_EMPTY_ARRAY),
-		  Tree.Empty,
-		  templ);
-                defineSym(cd, unit, context);
-		//new TextTreePrinter().print(cd).println().end();//DEBUG
-		val cd1 = transform(cd);
-		{
-		  // compute template's type with new refinement scope.
-		  val parentTypes = clazz.info().parents();
-		  val refinement: Scope = new Scope();
-		  val base: Type = Type.compoundTypeWithOwner(context.enclClass.owner, parentTypes, Scope.EMPTY);
-		  val it: Scope$SymbolIterator = clazz.members().iterator();
-		  while (it.hasNext()) {
-		    val sym1: Symbol = it.next();
-		    val basesym1: Symbol = base.lookupNonPrivate(sym1.name);
-		    if (basesym1.kind != NONE &&
-			!base.symbol().thisType().memberType(basesym1)
-			.isSameAs(sym1.getType()))
-		      refinement.enter(sym1);
-		  }
-		  val owntype =
-		    if (refinement.isEmpty() && parentTypes.length == 1)
-		      parentTypes(0)
-		    else
-		      checkNoEscape(
-			tree.pos,
-			Type.compoundTypeWithOwner(
-                          context.enclClass.owner, parentTypes, refinement));
-		  val alloc: Tree =
-		    gen.New(
-		      gen.Apply(
-			gen.mkLocalRef(
-			  tree.pos,
-			  clazz.primaryConstructor()),
-			Tree.EMPTY_ARRAY))
-		    .setType(owntype);
-		  popContext();
-		  make.Block(tree.pos, NewArray.Tree(cd1), alloc)
-		    .setType(owntype);
-		}
-	      }
-	  }
+	case Tree$New(init) =>
+	  val init1: Tree = transform(init, CONSTRmode, pt);
+	  checkInstantiatable(tree.pos, init1.getType());
+	  val tree1 = gen.New(tree.pos, init1);
+          val clazz = tree1.getType().symbol();
+          if (clazz.isAnonymousClass()) {
+	    val parentTypes = clazz.info().parents();
+	    val refinement: Scope = new Scope();
+	    val base: Type = Type.compoundTypeWithOwner(context.enclClass.owner, parentTypes, Scope.EMPTY);
+	    val it: Scope$SymbolIterator = clazz.members().iterator();
+	    while (it.hasNext()) {
+	      val sym1: Symbol = it.next();
+	      val basesym1: Symbol = base.lookupNonPrivate(sym1.name);
+	      if (!basesym1.isNone() &&
+                  !base.symbol().thisType().memberType(basesym1)
+		  .isSameAs(sym1.getType()))
+		refinement.enter(sym1);
+	    }
+	    val owntype =
+	      if (refinement.isEmpty() && parentTypes.length == 1)
+		parentTypes(0)
+	      else
+		checkNoEscape(
+		  tree.pos,
+		  Type.compoundTypeWithOwner(
+                    context.enclClass.owner, parentTypes, refinement));
+            gen.Typed(tree1, owntype)
+          } else
+            tree1
 
 	case Tree$Typed(expr, tpe) =>
 	  expr match {
diff --git a/sources/scala/tools/scalai/ExpressionCompiler.java b/sources/scala/tools/scalai/ExpressionCompiler.java
index 056af39e57..3f285af077 100644
--- a/sources/scala/tools/scalai/ExpressionCompiler.java
+++ b/sources/scala/tools/scalai/ExpressionCompiler.java
@@ -137,12 +137,10 @@ public class ExpressionCompiler {
             return Code.Switch(
                 compute(test), tags, compute(bodies), compute(otherwise));
 
-        case New(Tree.Template(Tree[] bases, Tree[] body)): // !!!
-            assert bases.length == 1 : Debug.show(tree);
-            assert body.length == 0 : Debug.show(tree);
+        case New(Tree init): // !!!
             Symbol symbol = Symbol.NONE.newTerm(tree.pos, 0, Name.fromString("new")); // !!! should be newVariable
             Variable variable = Variable.Local(context.push());
-            Code code = compute(bases[0]);
+            Code code = compute(init);
             switch (context.lookupTemplate(tree.getType().symbol())) {
             case Global(ScalaTemplate template):
                 assert code instanceof Code.Invoke : Debug.show(code);
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();