*** empty log message ***

11 files changed, 35 insertions, 36 deletions

diff --git a/sources/scalac/transformer/AddAccessors.java b/sources/scalac/transformer/AddAccessors.java
index 5628bdb3fe..3d3c5a9ba8 100644
--- a/sources/scalac/transformer/AddAccessors.java
+++ b/sources/scalac/transformer/AddAccessors.java
@@ -62,7 +62,6 @@ public class AddAccessors extends Transformer {
                       Tree tpe,
                       Tree.Template impl): {
             Symbol clsSym = tree.symbol();
-            Symbol constrSym = clsSym.constructor();
 
             LinkedList/*<Tree>*/ newBody =
                 new LinkedList(Arrays.asList(transform(impl.body)));
diff --git a/sources/scalac/transformer/AddConstructors.java b/sources/scalac/transformer/AddConstructors.java
index bf7cd290c5..226b476dc5 100644
--- a/sources/scalac/transformer/AddConstructors.java
+++ b/sources/scalac/transformer/AddConstructors.java
@@ -122,7 +122,7 @@ public class AddConstructors extends Transformer {
 	    ArrayList constrBody2 = new ArrayList();
 	    ArrayList classBody = new ArrayList();
 	    Symbol constrSym =
-		getConstructor(treeSym.constructor(), paramSyms, treeSym);
+		getConstructor(treeSym.primaryConstructor(), paramSyms, treeSym);
 	    Scope classScope = new Scope();
 	    classScope.enter(constrSym);
 
@@ -216,9 +216,9 @@ public class AddConstructors extends Transformer {
 	    classBody.add(gen.DefDef(tree.pos, constrSym, constrTree));
 
 	    // strip off the class constructor from parameters
-	    switch (treeSym.constructor().info()) {
+	    switch (treeSym.primaryConstructor().info()) {
 	    case MethodType(_, Type result):
-		treeSym.constructor().
+		treeSym.primaryConstructor().
 		    updateInfo(Type.MethodType(Symbol.EMPTY_ARRAY, result));
 		break;
 	    default : assert false;
@@ -235,6 +235,7 @@ public class AddConstructors extends Transformer {
 	    Tree base = baseClasses[0];
 	    switch (base) {
 	    case Apply(Tree fun, Tree[] args):
+		//System.out.println(tree + " new " + fun.symbol());//DEBUG
                 return gen.New(copy.Apply
 			       (base,
 				gen.Ident(base.pos, getConstructor(fun.symbol())),
diff --git a/sources/scalac/transformer/AddInterfaces.java b/sources/scalac/transformer/AddInterfaces.java
index 3d11c5b019..ec18661c8c 100644
--- a/sources/scalac/transformer/AddInterfaces.java
+++ b/sources/scalac/transformer/AddInterfaces.java
@@ -172,8 +172,8 @@ class AddInterfaces extends Transformer {
                 // constructor, use the class constructor instead.
                 Symbol clsSym = sym.primaryConstructorClass();
                 if (phase.needInterface(clsSym))
-                    return gen.Select(transform(qualifier),
-                                      phase.getClassSymbol(clsSym).constructor());
+                    return gen.Select(qualifier,
+                                      phase.getClassSymbol(clsSym).primaryConstructor());
                 else
                     return super.transform(tree);
             } else {
@@ -207,7 +207,7 @@ class AddInterfaces extends Transformer {
                 // constructor, use the class constructor instead.
                 Symbol clsSym = sym.primaryConstructorClass();
                 if (phase.needInterface(clsSym))
-                    return gen.Ident(phase.getClassSymbol(clsSym).constructor());
+                    return gen.Ident(phase.getClassSymbol(clsSym).primaryConstructor());
                 else
                     return super.transform(tree);
             } else if (typeSubst != null) {
@@ -228,7 +228,7 @@ class AddInterfaces extends Transformer {
                 Map clsMap = new HashMap();
                 Symbol classSym = phase.getClassSymbol(ifaceSym);
                 clsMap.put(ifaceSym, classSym);
-                clsMap.put(ifaceSym.constructor(), classSym.constructor());
+                clsMap.put(ifaceSym.primaryConstructor(), classSym.primaryConstructor());
 
                 SymbolSubstTypeMap clsSubst =
                     new SymbolSubstTypeMap(clsMap, Collections.EMPTY_MAP);
diff --git a/sources/scalac/transformer/AddInterfacesPhase.java b/sources/scalac/transformer/AddInterfacesPhase.java
index 18df3f4cee..77b9fdb5b2 100644
--- a/sources/scalac/transformer/AddInterfacesPhase.java
+++ b/sources/scalac/transformer/AddInterfacesPhase.java
@@ -40,8 +40,8 @@ public class AddInterfacesPhase extends PhaseDescriptor {
     }
 
     public Type transformInfo(Symbol sym, Type tp) {
-        if (sym.isConstructor()) {
-            Symbol clazz =sym.primaryConstructorClass();
+        if (sym.isPrimaryConstructor()) {
+            Symbol clazz = sym.primaryConstructorClass();
             if (clazz.isPackage() || !needInterface(clazz)) return tp;
             // The symbol is a constructor of a class which needs
             // an interface. All its value arguments have to be
@@ -165,7 +165,6 @@ public class AddInterfacesPhase extends PhaseDescriptor {
         uniqueName(sym, buf);
         Name newName = Name.fromString(buf.toString());
         if (sym.name.isTypeName()) return newName.toTypeName();
-        else if (sym.name.isConstrName()) return newName.toConstrName();
         else return newName;
     }
 
@@ -192,7 +191,6 @@ public class AddInterfacesPhase extends PhaseDescriptor {
     protected Name className(Name ifaceName) {
         Name className = Name.fromString(ifaceName.toString() + CLASS_SUFFIX);
         if (ifaceName.isTypeName()) return className.toTypeName();
-        else if (ifaceName.isConstrName()) return className.toConstrName();
         else return className;
     }
 
@@ -206,7 +204,7 @@ public class AddInterfacesPhase extends PhaseDescriptor {
     protected Symbol getClassSymbol(Symbol ifaceSym) {
         if (ifaceSym.isPrimaryConstructor())
             return getClassSymbol(ifaceSym.primaryConstructorClass())
-                .constructor();
+                .primaryConstructor();
 
         if (!needInterface(ifaceSym))
             return ifaceSym;
@@ -217,13 +215,13 @@ public class AddInterfacesPhase extends PhaseDescriptor {
             classSym.name = className(ifaceSym.name);
             classSym.flags &= ~Modifiers.INTERFACE;
 
-            Symbol ifaceConstrSym = ifaceSym.constructor();
-            Symbol classConstrSym = classSym.constructor();
+            Symbol ifaceConstrSym = ifaceSym.primaryConstructor();
+            Symbol classConstrSym = classSym.primaryConstructor();
             classConstrSym.name = className(ifaceConstrSym.name);
 
             Scope ifaceOwnerMembers = ifaceSym.owner().members();
             ifaceOwnerMembers.enter(classSym);
-            ifaceOwnerMembers.enter(classConstrSym);
+            // ifaceOwnerMembers.enter(classConstrSym);
 
             Type.SubstThisMap thisTypeMap =
                 new Type.SubstThisMap(ifaceSym, classSym);
@@ -278,7 +276,7 @@ public class AddInterfacesPhase extends PhaseDescriptor {
                 classMembersMap.put(ifaceMemberSym, classMemberSym);
                 classMembers.enterOrOverload(classMemberSym);
                 if (classMemberSym.isClass())
-                    classMembers.enterOrOverload(classMemberSym.constructor());
+                    classMembers.enterOrOverload(classMemberSym.primaryConstructor());
             }
 
             // Give correct type to the class symbol by using class
diff --git a/sources/scalac/transformer/ExpandMixins.java b/sources/scalac/transformer/ExpandMixins.java
index dc4d9a04ef..57ab76a5e9 100644
--- a/sources/scalac/transformer/ExpandMixins.java
+++ b/sources/scalac/transformer/ExpandMixins.java
@@ -95,7 +95,7 @@ public class ClassExpander {
         switch (parents[i]) {
         case TypeRef(Type prefix, Symbol mixin, Type[] args):
             map.insertSymbol(mixin, clasz);
-            cloner.owners.put(mixin.constructor(), clasz);
+            cloner.owners.put(mixin.primaryConstructor(), clasz);
             inlineMixinTParams(type);
             Tree.Apply constr = (Tree.Apply)template.parents[i];
             inlineMixinVParams(mixin.valueParams(), constr.args);
diff --git a/sources/scalac/transformer/ExplicitOuterClasses.java b/sources/scalac/transformer/ExplicitOuterClasses.java
index d60507288c..b71a063b5d 100644
--- a/sources/scalac/transformer/ExplicitOuterClasses.java
+++ b/sources/scalac/transformer/ExplicitOuterClasses.java
@@ -117,7 +117,7 @@ public class ExplicitOuterClasses extends Transformer {
             } else {
                 // Add the outer parameter to the tree (it is added to
                 // the type by transformInfo).
-                Symbol constSym = classSym.constructor();
+                Symbol constSym = classSym.primaryConstructor();
                 Symbol outerSym = phase.outerSym(constSym);
                 assert (outerSym.owner() == constSym) : outerSym;
                 outerLinks.addFirst(outerSym);
diff --git a/sources/scalac/transformer/LambdaLift.java b/sources/scalac/transformer/LambdaLift.java
index acfa0f9c49..099b26a46d 100644
--- a/sources/scalac/transformer/LambdaLift.java
+++ b/sources/scalac/transformer/LambdaLift.java
@@ -58,7 +58,7 @@ public class LambdaLift extends OwnerTransformer
      *  otherwise current symbol itself
      */
     static Symbol asFunction(Symbol sym) {
-	return sym.kind == CLASS ? sym.constructor() : sym;
+	return sym.kind == CLASS ? sym.primaryConstructor() : sym;
     }
 
     /** `asFunction' applied to the next enclosing function or class owner.
@@ -174,7 +174,7 @@ public class LambdaLift extends OwnerTransformer
 	    Name newname = global.freshNameCreator.newName(sym.name);
 	    sym.name = newname;
 	    if (sym.kind == CLASS)
-		sym.constructor().name = newname.toConstrName();
+		sym.primaryConstructor().name = newname.toTypeName();
 	}
 
 	private Type.Map traverseTypeMap = new Type.Map() {
@@ -327,9 +327,9 @@ public class LambdaLift extends OwnerTransformer
 		((ClassDef) tree).mods &= ~LIFTED;
 		Tree tree1 = copy.ClassDef(
 		    tree, sym,
-		    addTypeParams(transform(tparams, sym), newtparams(sym.constructor())),
+		    addTypeParams(transform(tparams, sym), newtparams(sym.primaryConstructor())),
 		    new ValDef[][]{
-			addParams(transform(vparams, sym)[0], newparams(sym.constructor()))},
+			addParams(transform(vparams, sym)[0], newparams(sym.primaryConstructor()))},
 		    transform(tpe, sym),
 		    transform(impl, sym));
 		liftedDefs.append(tree1);
@@ -488,7 +488,7 @@ public class LambdaLift extends OwnerTransformer
 	    ((ClassDef) tree).mods |= LIFTED;
 	    Symbol sym = tree.symbol();
 	    assert sym.isLocal() : sym;
-	    liftSymbol(sym, ftvsParams(sym.constructor()), fvsParams(sym.constructor()));
+	    liftSymbol(sym, ftvsParams(sym.primaryConstructor()), fvsParams(sym.primaryConstructor()));
 	    break;
 
 	case DefDef(_, _, _, _, _, _):
@@ -502,7 +502,7 @@ public class LambdaLift extends OwnerTransformer
     void liftSymbol(Symbol sym, Symbol[] newtparams, Symbol[] newparams) {
 	Symbol enclClass = sym.owner().enclClass();
 	if (!sym.isPrimaryConstructor()) sym.setOwner(enclClass);
-	enclClass.members().enter(sym);
+	if (!sym.isConstructor()) enclClass.members().enter(sym);
 	if (sym.isMethod()) {
 	    if (newtparams.length != 0 || newparams.length != 0) {
 		sym.updateInfo(
@@ -513,7 +513,7 @@ public class LambdaLift extends OwnerTransformer
 		    global.log(sym + " has now type " + sym.typeAt(descr.nextPhase));
 	    }
 	} else if (sym.kind == CLASS) {
-	    liftSymbol(sym.constructor(), newtparams, newparams);
+	    liftSymbol(sym.primaryConstructor(), newtparams, newparams);
 	} else {
 	    throw new ApplicationError();
 	}
@@ -609,7 +609,7 @@ public class LambdaLift extends OwnerTransformer
 		gen.TypeApply(
 		    gen.mkRef(
 			pos,
-			global.definitions.getClass(Names.scala_COLONCOLON).constructor()),
+			global.definitions.getClass(Names.scala_COLONCOLON).primaryConstructor()),
 		    new Tree[]{gen.mkType(pos, elemtpe)}),
 		new Tree[]{hd, tl}));
     }
diff --git a/sources/scalac/transformer/LambdaLiftPhase.java b/sources/scalac/transformer/LambdaLiftPhase.java
index 563710cb51..a61011cfc9 100644
--- a/sources/scalac/transformer/LambdaLiftPhase.java
+++ b/sources/scalac/transformer/LambdaLiftPhase.java
@@ -85,14 +85,15 @@ public class LambdaLiftPhase extends PhaseDescriptor implements Kinds, Modifiers
             case TypeRef(Type pre, Symbol sym, Type[] targs):
                 switch (pre) {
                 case ThisType(_):
-                    if (sym.kind == CLASS && sym.constructor().isUpdated(nextPhase)) {
+                    if (sym.kind == CLASS &&
+			sym.primaryConstructor().isUpdated(nextPhase)) {
                         // !!! For some Java classes,
                         // Symbol.constructor() returns an Overloaded
                         // symbol. This is wrong as constructor()
                         // should return the primary constructor. Once
                         // this problem is solved, the following
                         // switch can be removed.
-                        Type constrtype = sym.constructor().infoAt(nextPhase);
+                        Type constrtype = sym.primaryConstructor().infoAt(nextPhase);
                         Symbol[] tparams;
                         switch (constrtype) {
                         case OverloadedType(_, _):
diff --git a/sources/scalac/transformer/OwnerTransformer.java b/sources/scalac/transformer/OwnerTransformer.java
index 66e68ff45b..587362e345 100644
--- a/sources/scalac/transformer/OwnerTransformer.java
+++ b/sources/scalac/transformer/OwnerTransformer.java
@@ -62,7 +62,7 @@ public class OwnerTransformer extends Transformer {
     public Template transform(Template templ, Symbol owner) {
 	Symbol prevOwner = currentOwner;
 	if (owner.kind == Kinds.CLASS)
-	    currentOwner = owner.constructor();
+	    currentOwner = owner.primaryConstructor();
 	Tree[] parents1 = transform(templ.parents);
 	currentOwner = owner;
 	Tree[] body1 = transformTemplateStats(templ.body, templ.symbol());
@@ -99,8 +99,8 @@ public class OwnerTransformer extends Transformer {
             Symbol symbol = tree.symbol();
 	    return copy.ClassDef(
 		tree, symbol,
-		transform(tparams, symbol.constructor()),
-		transform(vparams, symbol.constructor()),
+		transform(tparams, symbol.primaryConstructor()),
+		transform(vparams, symbol.primaryConstructor()),
 		transform(tpe),
 		transform(impl, symbol));
 
diff --git a/sources/scalac/transformer/matching/AlgebraicMatcher.java b/sources/scalac/transformer/matching/AlgebraicMatcher.java
index 67fc972798..aba3f9d90b 100644
--- a/sources/scalac/transformer/matching/AlgebraicMatcher.java
+++ b/sources/scalac/transformer/matching/AlgebraicMatcher.java
@@ -441,8 +441,8 @@ public class AlgebraicMatcher extends PatternTool {
     protected int nCaseComponents(Tree tree) {
         switch (tree) {
             case Apply(Tree fn, _):
-                Type tpe = typeOf(tree.type.symbol().constructor());
-                //System.out.println("~~~ " + tree.type() + ", " + tree.type().symbol().constructor());
+                Type tpe = typeOf(tree.type.symbol().primaryConstructor());
+                //System.out.println("~~~ " + tree.type() + ", " + tree.type().symbol().primaryConstructor());
                 switch (tpe) {
                     // I'm not sure if this is a good idea, but obviously, currently all case classes
                     // without constructor arguments have type NoType
diff --git a/sources/scalac/transformer/matching/PatternMatcher.java b/sources/scalac/transformer/matching/PatternMatcher.java
index f3f52d8074..2420e361b3 100644
--- a/sources/scalac/transformer/matching/PatternMatcher.java
+++ b/sources/scalac/transformer/matching/PatternMatcher.java
@@ -589,8 +589,8 @@ public class PatternMatcher extends PatternTool {
     protected int nCaseComponents(Tree tree) {
         switch (tree) {
             case Apply(Tree fn, _):
-                Type tpe = typeOf(tree.type.symbol().constructor());
-                //System.out.println("~~~ " + tree.type() + ", " + tree.type().symbol().constructor());
+                Type tpe = typeOf(tree.type.symbol().primaryConstructor());
+                //System.out.println("~~~ " + tree.type() + ", " + tree.type().symbol().primaryConstructor());
                 switch (tpe) {
                     // I'm not sure if this is a good idea, but obviously, currently all case classes
                     // without constructor arguments have type NoType