- Introduced local and global refs

- Fixed related bugs in ExplicitOuter
- Replaced TreeGen.mkPrimaryConstr by TreeGen.mkPrimaryConstructorRef methods

4 files changed, 39 insertions, 37 deletions

diff --git a/sources/scalac/transformer/Erasure.java b/sources/scalac/transformer/Erasure.java
index 244712fe36..0de4624d01 100644
--- a/sources/scalac/transformer/Erasure.java
+++ b/sources/scalac/transformer/Erasure.java
@@ -295,7 +295,7 @@ public class Erasure extends GenTransformer implements Modifiers {
     private Tree transformUnit(int pos, Type pt) {
         Tree unit = pt.isSameAs(UNBOXED_UNIT)
             ? gen.mkUnitLit(pos)
-            : gen.mkApply__(gen.mkRef(pos, primitives.BOX_UVALUE));
+            : gen.mkApply__(gen.mkGlobalRef(pos, primitives.BOX_UVALUE));
         return coerce(unit, pt);
     }
 
@@ -305,7 +305,7 @@ public class Erasure extends GenTransformer implements Modifiers {
             if (tree.type().symbol() == definitions.ARRAY_CLASS) {
                 if (pt.symbol() != definitions.ARRAY_CLASS) {
                     Symbol symbol = primitives.UNBOX__ARRAY;
-                    Tree unboxtree = gen.mkRef(tree.pos, symbol);
+                    Tree unboxtree = gen.mkGlobalRef(tree.pos, symbol);
                     tree = gen.mkApply_V(unboxtree, new Tree[] {tree});
                     return coerce(tree, pt);
                 }
@@ -331,7 +331,7 @@ public class Erasure extends GenTransformer implements Modifiers {
             if (tree.type.symbol() == definitions.ARRAY_CLASS)
                 return unbox(tree, pt);
         } else if (pt.symbol() == definitions.ARRAY_CLASS) {
-            Tree boxtree = gen.mkRef(tree.pos, primitives.BOX__ARRAY);
+            Tree boxtree = gen.mkGlobalRef(tree.pos, primitives.BOX__ARRAY);
             return gen.mkApply_V(boxtree, new Tree[]{tree});
         }
         return gen.mkAsInstanceOf(tree, pt);
@@ -352,7 +352,7 @@ public class Erasure extends GenTransformer implements Modifiers {
             }
         }
         Symbol symbol = primitives.getBoxValueSymbol(tree.getType());
-	Tree boxtree = gen.mkRef(tree.pos, symbol);
+	Tree boxtree = gen.mkGlobalRef(tree.pos, symbol);
         return tree.getType().equals(UNBOXED_UNIT)
             ? gen.Block(new Tree[]{tree, gen.mkApply__(boxtree)})
             : gen.mkApply_V(boxtree, new Tree[]{tree});
@@ -368,13 +368,15 @@ public class Erasure extends GenTransformer implements Modifiers {
             }
         }
         Symbol symbol = primitives.getUnboxValueSymbol(pt);
-        return gen.mkApply_V(gen.mkRef(tree.pos, symbol), new Tree[]{tree});
+        return gen.mkApply_V(
+            gen.mkGlobalRef(tree.pos, symbol), new Tree[]{tree});
     }
 
     /** Converts the given tree to the given type. */
     private Tree convert(Tree tree, Type to) {
         Symbol symbol = primitives.getConvertSymbol(tree.type(), to);
-        return gen.mkApply_V(gen.mkRef(tree.pos, symbol), new Tree[]{tree});
+        return gen.mkApply_V(
+            gen.mkGlobalRef(tree.pos, symbol), new Tree[]{tree});
     }
 
     //########################################################################
@@ -385,7 +387,7 @@ public class Erasure extends GenTransformer implements Modifiers {
         Type type = bridge.nextType();
         Tree body = genApply(bridge.pos,
             gen.Select(gen.This(bridge.pos, bridge.owner()), method),
-            gen.mkRefs(bridge.pos, type.valueParams()));
+            gen.mkLocalRefs(bridge.pos, type.valueParams()));
         return gen.DefDef(bridge, coerce(body, type.resultType()));
     }
 
@@ -440,7 +442,8 @@ public class Erasure extends GenTransformer implements Modifiers {
         }
         String name = primitives.getNameForClassForName(element);
         Tree[] args = { coerce(size, UNBOXED_INT), gen.mkStringLit(pos,name) };
-        Tree array = gen.mkApply_V(gen.mkRef(pos,primitives.NEW_OARRAY), args);
+        Tree array =
+            gen.mkApply_V(gen.mkGlobalRef(pos,primitives.NEW_OARRAY), args);
         return gen.mkAsInstanceOf(array, Type.UnboxedArrayType(element));
     }
 
@@ -451,7 +454,7 @@ public class Erasure extends GenTransformer implements Modifiers {
     private Tree genNewUnboxedArray(int pos, int kind, Tree size) {
         Symbol symbol = primitives.getNewArraySymbol(kind);
         Tree[] args = { coerce(size, UNBOXED_INT) };
-        return gen.mkApply_V(gen.mkRef(pos, symbol), args);
+        return gen.mkApply_V(gen.mkGlobalRef(pos, symbol), args);
     }
 
     /** Generates an unboxed array length operation. */
@@ -459,7 +462,7 @@ public class Erasure extends GenTransformer implements Modifiers {
         assert isUnboxedArrayType(array.getType()): array;
         Symbol symbol = primitives.getArrayLengthSymbol(array.getType());
         Tree[] args = { array };
-        return gen.mkApply_V(gen.mkRef(pos, symbol), args);
+        return gen.mkApply_V(gen.mkGlobalRef(pos, symbol), args);
     }
 
     /** Generates an unboxed array get operation. */
@@ -468,7 +471,7 @@ public class Erasure extends GenTransformer implements Modifiers {
         Symbol symbol = primitives.getArrayGetSymbol(array.getType());
         index = coerce(index, UNBOXED_INT);
         Tree[] args = { array, index };
-        return gen.mkApply_V(gen.mkRef(pos, symbol), args);
+        return gen.mkApply_V(gen.mkGlobalRef(pos, symbol), args);
     }
 
     /** Generates an unboxed array set operation. */
@@ -478,7 +481,7 @@ public class Erasure extends GenTransformer implements Modifiers {
         index = coerce(index, UNBOXED_INT);
         value = coerce(value, getArrayElementType(array.getType()));
         Tree[] args = { array, index, value };
-        return gen.mkApply_V(gen.mkRef(pos, symbol), args);
+        return gen.mkApply_V(gen.mkGlobalRef(pos, symbol), args);
     }
 
     //########################################################################
diff --git a/sources/scalac/transformer/ExplicitOuterClassesPhase.java b/sources/scalac/transformer/ExplicitOuterClassesPhase.java
index 0224d36f91..57c5067862 100644
--- a/sources/scalac/transformer/ExplicitOuterClassesPhase.java
+++ b/sources/scalac/transformer/ExplicitOuterClassesPhase.java
@@ -260,8 +260,7 @@ public class ExplicitOuterClassesPhase extends Phase {
         public Type getTypeLink(int level) {
             if (tlinks.length <= level) return Type.localThisType;
             if (tlinks[level] != null) return tlinks[level].type();
-            // !!! if (clasz.isPackage()) return Type.localThisType;
-            return Type.singleType(getTypeLink(level + 1), clasz.module());
+            return Type.singleType(getTypeLink(level + 1), outers[level].clasz.module());
         }
 
         public String toString() {
@@ -318,14 +317,9 @@ public class ExplicitOuterClassesPhase extends Phase {
             case ThisType(Symbol clasz):
                 if (clasz == Symbol.NONE) return type;
                 if (clasz == context.clasz) return type;
-                if (clasz.isPackage()) return Type.localThisType;
                 for (int i = 0; i < context.outers.length; i++)
                     if (clasz == context.outers[i].clasz)
                         return context.getTypeLink(i);
-                if (clasz.isModuleClass()) {
-                    Type prefix = clasz.owner().thisType();
-                    return Type.singleType(apply(prefix), clasz.module());
-                }
                 throw Debug.abort("illegal ThisType", type);
             case CompoundType(Type[] parents, Scope members):
                 // !!! this case should not be needed
@@ -397,6 +391,8 @@ public class ExplicitOuterClassesPhase extends Phase {
 
             case This(_):
                 return genOuterRef(tree.pos, tree.symbol());
+//                 Symbol clasz = tree.symbol();
+//                 return clasz.isRoot() ? tree : genOuterRef(tree.pos, clasz);
 
             case Select(Tree qualifier, _):
                 Symbol symbol = tree.symbol();
@@ -510,7 +506,7 @@ public class ExplicitOuterClassesPhase extends Phase {
                 Symbol forward = (Symbol)entry.getValue();
                 int pos = forward.pos;
                 Tree[] targs = gen.mkTypeRefs(pos, forward.nextTypeParams());
-                Tree[] vargs = gen.mkRefs(pos, forward.nextValueParams());
+                Tree[] vargs = gen.mkLocalRefs(pos, forward.nextValueParams());
                 Tree fun = gen.Select(gen.Super(pos, context.clasz), method);
                 trees[i] = gen.DefDef(forward, gen.mkApplyTV(fun,targs,vargs));
             }
diff --git a/sources/scalac/transformer/LambdaLift.java b/sources/scalac/transformer/LambdaLift.java
index 1acc0ba676..c2f1378a60 100644
--- a/sources/scalac/transformer/LambdaLift.java
+++ b/sources/scalac/transformer/LambdaLift.java
@@ -417,18 +417,21 @@ public class LambdaLift extends OwnerTransformer
 		transform(tparams, currentOwner),
 		transform(rhs, currentOwner));
 
-	case ValDef(_, _, Tree tpe, Tree rhs):
+	case ValDef(_, _, _, Tree rhs):
 	    Symbol sym = tree.symbol();
-	    Tree tpe1 = transform(tpe);
-	    Tree rhs1 = transform(rhs, sym);
+	    rhs = transform(rhs, sym);
 	    if ((sym.flags & CAPTURED) != 0) {
 		assert sym.isLocal();
-		Type boxedType = sym.nextType();
-		tpe1 = gen.mkType(tpe.pos, boxedType);
-		rhs1 = gen.New(
-                    gen.mkPrimaryConstr(rhs.pos, boxedType, new Tree[]{rhs1}));
+                switch (sym.nextType()) {
+                case TypeRef(_, Symbol clasz, Type[] args):
+                    Tree constr = gen.mkPrimaryConstructorGlobalRef(rhs.pos, clasz);
+                    rhs = gen.New(gen.mkApplyTV(constr, args, new Tree[]{rhs}));
+                    break;
+                default:
+                    throw Debug.abort("illegal case", sym.nextType());
+                }
 	    }
-	    return copy.ValDef(tree, sym, tpe1, rhs1);
+	    return gen.ValDef(sym, rhs);
 
 	case Sequence(Tree[] args):
 	    Tree tree1 = gen.mkNewList(tree.pos, tree.type.typeArgs()[0], transform(args));
@@ -486,7 +489,7 @@ public class LambdaLift extends OwnerTransformer
 		sym = descr.proxy(sym, currentOwner);
 	    }
 	    Tree tree1 = (sym.owner().kind == CLASS)
-		? gen.mkRef(tree.pos, sym)
+		? gen.mkLocalRef(tree.pos, sym)
 		: copy.Ident(tree, sym).setType(sym.nextType());
 	    if (name != sym.name) {
 		if (tree1 instanceof Ident) ((Ident)tree1).name = sym.name;
diff --git a/sources/scalac/transformer/matching/CodeFactory.java b/sources/scalac/transformer/matching/CodeFactory.java
index 36c4a29683..8bb592327e 100644
--- a/sources/scalac/transformer/matching/CodeFactory.java
+++ b/sources/scalac/transformer/matching/CodeFactory.java
@@ -69,9 +69,9 @@ class CodeFactory extends PatternTool {
     // EXPERIMENTAL
     Tree newRef( Tree init ) {
 	//System.out.println( "hello:"+refSym().type() );
-	return gen.New(gen.mkPrimaryConstr(pos, defs.REF_CLASS,
-			                    new Type[] { init.getType() },
-			                    new Tree[] { init } ));
+	return gen.New( gen.mkApplyTV( gen.mkPrimaryConstructorGlobalRef( pos, defs.REF_CLASS),
+                                                                    new Type[] { init.getType() },
+                                                                    new Tree[] { init } ));
     }
 
     /** returns A for T <: Sequence[ A ]
@@ -187,7 +187,7 @@ class CodeFactory extends PatternTool {
 
     protected Tree ThrowMatchError(int pos, Type type) {
         return gen.mkApplyTV(
-			     gen.mkRef(pos, defs.MATCHERROR_FAIL()),
+			     gen.mkGlobalRef(pos, defs.MATCHERROR_FAIL()),
                              new Tree[]{gen.mkType(pos, type)},
                              new Tree[]{
                                  gen.mkStringLit(pos, unit.toString()),
@@ -197,7 +197,7 @@ class CodeFactory extends PatternTool {
 
     protected Tree Error(int pos, Type type) {
         return gen.mkApplyTV(
-			     gen.mkRef(pos, defs.MATCHERROR_FAIL()),
+			     gen.mkGlobalRef(pos, defs.MATCHERROR_FAIL()),
                              new Tree[]{gen.mkType(pos, type)},
                              new Tree[]{
                                  gen.mkStringLit(pos, unit.toString()),
@@ -211,9 +211,9 @@ class CodeFactory extends PatternTool {
     }
 
     Tree newPair( Tree left, Tree right ) {
- 	return gen.New(gen.mkPrimaryConstr(pos, defs.TUPLE_CLASS[2],
-			                   new Type[] { left.getType(), right.getType() },
-			                   new Tree[] { left, right }));
+ 	return gen.New(gen.mkApplyTV( gen.mkPrimaryConstructorGlobalRef( pos, defs.TUPLE_CLASS[2]),
+                                                                   new Type[] { left.getType(), right.getType() },
+                                                                   new Tree[] { left, right }));
 
     }