- multiple constructors are now supported

2 files changed, 30 insertions, 7 deletions

diff --git a/sources/scalac/transformer/ExplicitOuterClasses.java b/sources/scalac/transformer/ExplicitOuterClasses.java
index 47937f515a..6a64127b5c 100644
--- a/sources/scalac/transformer/ExplicitOuterClasses.java
+++ b/sources/scalac/transformer/ExplicitOuterClasses.java
@@ -179,6 +179,22 @@ public class ExplicitOuterClasses extends Transformer {
                                                newBody.toArray()));
         }
 
+        case DefDef(_, _, _, _, _, Tree rhs): {
+            Symbol sym = tree.symbol();
+            if (sym.isConstructor()) {
+                // Temporarily set the outer link to the one passed to
+                // that constructor, to transform RHS.
+                Symbol mainOuterLink = (Symbol)outerLinks.removeFirst();
+                outerLinks.addFirst(phase.outerSym(sym));
+                Tree newRhs = transform(rhs);
+                outerLinks.removeFirst();
+                outerLinks.addFirst(mainOuterLink);
+
+                return gen.DefDef(tree.pos, sym, newRhs);
+            } else
+                return super.transform(tree);
+        }
+
         case Ident(_): {
             if (! tree.symbol().name.isTermName())
                 return super.transform(tree);
@@ -228,7 +244,7 @@ public class ExplicitOuterClasses extends Transformer {
 
             Tree newFun = null, newArg = null;
 
-            if (realFun.hasSymbol() && realFun.symbol().isPrimaryConstructor()) {
+            if (realFun.hasSymbol() && realFun.symbol().isConstructor()) {
                 switch (transform(realFun)) {
                 case Select(Tree qualifier, _): {
                     if (! (qualifier.hasSymbol()
@@ -263,8 +279,7 @@ public class ExplicitOuterClasses extends Transformer {
                         finalFun = newFun;
 
                     finalFun.type =
-                        phase.addValueParam(finalFun.type,
-                                            phase.outerSym(realFun.symbol()));
+                        phase.addOuterValueParam(finalFun.type, realFun.symbol());
                     return copy.Apply(tree, finalFun, transform(newArgs));
                 } else
                     return super.transform(tree);
diff --git a/sources/scalac/transformer/ExplicitOuterClassesPhase.java b/sources/scalac/transformer/ExplicitOuterClassesPhase.java
index ace14302f6..2819c14ef7 100644
--- a/sources/scalac/transformer/ExplicitOuterClassesPhase.java
+++ b/sources/scalac/transformer/ExplicitOuterClassesPhase.java
@@ -44,7 +44,7 @@ public class ExplicitOuterClassesPhase extends Phase {
             && sym.isConstructor()
             && sym.owner().isClass()
             && !(sym.isJava() || sym.owner().isRoot())) {
-            return addValueParam(tp, outerSym(sym));
+            return addOuterValueParam(tp, sym);
         } else
             return tp;
     }
@@ -71,17 +71,25 @@ public class ExplicitOuterClassesPhase extends Phase {
      * Add the given value parameter to the type, which must be the
      * type of a method, as the first argument.
      */
-    protected Type addValueParam(Type oldType, Symbol newValueParam) {
+    protected Type addOuterValueParam(Type oldType, Symbol constr) {
         switch (oldType) {
         case MethodType(Symbol[] vparams, Type result): {
             Symbol[] newVParams = new Symbol[vparams.length + 1];
-            newVParams[0] = newValueParam;
+            newVParams[0] = outerSym(constr);
             System.arraycopy(vparams, 0, newVParams, 1, vparams.length);
             return new Type.MethodType(newVParams, result);
         }
 
         case PolyType(Symbol[] tparams, Type result):
-            return new Type.PolyType(tparams, addValueParam(result, newValueParam));
+            return new Type.PolyType(tparams,
+                                     addOuterValueParam(result, constr));
+
+        case OverloadedType(Symbol[] alts, Type[] altTypes): {
+            Type[] newAltTypes = new Type[altTypes.length];
+            for (int i = 0; i < newAltTypes.length; ++i)
+                newAltTypes[i] = addOuterValueParam(altTypes[i], alts[i]);
+            return new Type.OverloadedType(alts, newAltTypes);
+        }
 
         default:
             throw Global.instance.fail("invalid type", oldType);