- handle a few more "special" types (All, AllRe...

- handle a few more "special" types (All, AllRef, etc.), various bug
- fixes

1 files changed, 132 insertions, 312 deletions

diff --git a/sources/scalac/transformer/TypesAsValuesPhase.java b/sources/scalac/transformer/TypesAsValuesPhase.java
index 698a7eb8d1..f52efa6521 100644
--- a/sources/scalac/transformer/TypesAsValuesPhase.java
+++ b/sources/scalac/transformer/TypesAsValuesPhase.java
@@ -102,7 +102,7 @@ public class TypesAsValuesPhase extends Phase {
 
     private final TEnv EENV = new TEnv();
 
-    private final Map/*<Symbol, Symbol>*/ basicTypes;
+    private final Map/*<Symbol, Symbol>*/ predefTypes;
 
     private HashMap/*<Symbol, Ancestor[][]>*/ displayCache = new HashMap();
 
@@ -110,15 +110,21 @@ public class TypesAsValuesPhase extends Phase {
         super(global, descriptor);
         transformer = new TV_Transformer(global);
 
-        basicTypes = new HashMap();
-        basicTypes.put(defs.DOUBLE_CLASS,  defs.RTT_DOUBLE());
-        basicTypes.put(defs.FLOAT_CLASS,   defs.RTT_FLOAT());
-        basicTypes.put(defs.LONG_CLASS,    defs.RTT_LONG());
-        basicTypes.put(defs.INT_CLASS,     defs.RTT_INT());
-        basicTypes.put(defs.SHORT_CLASS,   defs.RTT_SHORT());
-        basicTypes.put(defs.CHAR_CLASS,    defs.RTT_CHAR());
-        basicTypes.put(defs.BYTE_CLASS,    defs.RTT_BYTE());
-        basicTypes.put(defs.BOOLEAN_CLASS, defs.RTT_BOOLEAN());
+        predefTypes = new HashMap();
+        predefTypes.put(defs.DOUBLE_CLASS,  defs.RTT_DOUBLE());
+        predefTypes.put(defs.FLOAT_CLASS,   defs.RTT_FLOAT());
+        predefTypes.put(defs.LONG_CLASS,    defs.RTT_LONG());
+        predefTypes.put(defs.INT_CLASS,     defs.RTT_INT());
+        predefTypes.put(defs.SHORT_CLASS,   defs.RTT_SHORT());
+        predefTypes.put(defs.CHAR_CLASS,    defs.RTT_CHAR());
+        predefTypes.put(defs.BYTE_CLASS,    defs.RTT_BYTE());
+        predefTypes.put(defs.BOOLEAN_CLASS, defs.RTT_BOOLEAN());
+        predefTypes.put(defs.UNIT_CLASS,    defs.RTT_UNIT());
+
+        predefTypes.put(defs.ANY_CLASS,     defs.RTT_ANY());
+        predefTypes.put(defs.ANYVAL_CLASS,  defs.RTT_ANYVAL());
+        predefTypes.put(defs.ALLREF_CLASS,  defs.RTT_ALLREF());
+        predefTypes.put(defs.ALL_CLASS,     defs.RTT_ALL());
 
         membersToAdd.put(defs.ARRAY_CLASS, new NewMember[0]);
         paramsToAdd.put(ARRAY_CONSTRUCTOR, new Symbol[0]);
@@ -151,11 +157,14 @@ public class TypesAsValuesPhase extends Phase {
         Symbol imSym = (Symbol)instantiator.get(classSym);
         if (imSym == null) {
             int pos = classSym.pos;
-            Name imName = Names.INSTANTIATE(classSym);
+            boolean isStatic = !isNestedClass(classSym);
+            Name imName = Names.INSTANTIATE(classSym, isStatic);
 
-            imSym = isNestedClass(classSym)
-                ? classSym.owner().newMethod(pos, 0, imName)
-                : classSym.newStaticMethod(pos, 0, imName);
+            int flags = classSym.isAbstractType() ? Modifiers.DEFERRED : 0;
+
+            imSym = isStatic
+                ? classSym.newStaticMethod(pos, 0, imName)
+                : classSym.owner().newMethod(pos, flags, imName);
 
             // TODO special case for monomorphic instantiations
             Symbol[] argTypes;
@@ -179,11 +188,12 @@ public class TypesAsValuesPhase extends Phase {
         Symbol tcSym = (Symbol)tConstructor.get(classSym);
         if (tcSym == null) {
             int pos = classSym.pos;
-            Name tcName = Names.TYPECONSTRUCTOR(classSym);
+            boolean isStatic = !isNestedClass(classSym);
+            Name tcName = Names.TYPECONSTRUCTOR(classSym, isStatic);
 
-            tcSym = isNestedClass(classSym)
-                ? classSym.owner().newField(pos, 0, tcName)
-                : classSym.newStaticField(pos, 0, tcName);
+            tcSym = isStatic
+                ? classSym.newStaticField(pos, 0, tcName)
+                : classSym.owner().newField(pos, 0, tcName);
             tcSym.setInfo(defs.TYPECONSTRUCTOR_TYPE());
 
             tConstructor.put(classSym, tcSym);
@@ -212,6 +222,10 @@ public class TypesAsValuesPhase extends Phase {
             Scope.SymbolIterator membersIt = classSym.members().iterator();
             while (membersIt.hasNext()) {
                 Symbol member = membersIt.next();
+                // [HACK] work around a bug in the analyzer, which
+                // doesn't add the module class to its owner's members
+                if (member.isModule())
+                    member = member.moduleClass();
                 if (member.isClass()) {
                     Symbol tcSym = getTConstructorSym(member);
                     toAddL.add(NewMember.TypeConstructor(member, tcSym));
@@ -254,6 +268,19 @@ public class TypesAsValuesPhase extends Phase {
         return toAdd;
     }
 
+    /**
+     * Return true iff the given symbol is not a polymorphic
+     * primitive, which shouldn't get type parameters as value
+     * parameters.
+     */
+    private boolean monoPrimitive(Symbol sym) {
+        return sym.isJava()
+            || sym == ARRAY_CONSTRUCTOR
+            || sym == defs.OBJECT_SYNCHRONIZED
+            || sym == defs.ANY_IS
+            || sym == defs.ANY_AS;
+    }
+
     public Type transformInfo(Symbol symbol, Type type) {
         if (symbol.isClass()) {
             NewMember[] toAdd = membersToAdd(symbol);
@@ -268,7 +295,7 @@ public class TypesAsValuesPhase extends Phase {
 
                 return Type.compoundType(type.parents(), newMembers, symbol);
             }
-        } else if (type.typeParams().length > 0 && !isPrimitive(symbol)) {
+        } else if (type.typeParams().length > 0 && !monoPrimitive(symbol)) {
             // Polymorphic method/constructor:
             // - add a value parameter for every type parameter.
             switch (type) {
@@ -291,11 +318,6 @@ public class TypesAsValuesPhase extends Phase {
             return type;
     }
 
-    private boolean isPrimitive(Symbol sym) {
-        return sym == defs.ANY_IS
-            || sym == defs.ANY_AS;
-    }
-
     private boolean isNestedClass(Symbol classSym) {
         return !classSym.owner().isPackageClass();
     }
@@ -333,8 +355,7 @@ public class TypesAsValuesPhase extends Phase {
 //                 if (impl.symbol().isNone())
 //                     throw new Error("no symbol for " + tree);
 
-                TreeList newBody =
-                    new TreeList(transform(impl.body, impl.symbol()));
+                TreeList newBody = new TreeList();
                 // Add members (accessors and instantiators)
                 NewMember[] toAdd = membersToAdd(sym);
                 for (int i = 0; i < toAdd.length; ++i) {
@@ -355,6 +376,7 @@ public class TypesAsValuesPhase extends Phase {
                         break;
                     }
                 }
+                newBody.append(transform(impl.body, impl.symbol()));
 
                 Symbol pConst = sym.primaryConstructor();
 
@@ -442,31 +464,28 @@ public class TypesAsValuesPhase extends Phase {
                     return isTrivialType(type)
                         ? super.transform(tree)
                         : genTypeCast(tree.pos, expr, type);
-                } else {
+                } else if (!monoPrimitive(funSym)) {
                     // Transform applications to pass types as values:
                     //   f[T1, ...](v1, ...)
                     // becomes
                     //   f[T1, ...](asValue(T1), ..., v1, ...)
-                    if (funSym == ARRAY_CONSTRUCTOR)
-                        return super.transform(tree);
-                    else {
-                        Tree[] newVArgs = transform(vargs);
-                        Tree[] finalVArgs =
-                            new Tree[newVArgs.length + targs.length];
-                        for (int i = 0; i < targs.length; ++i)
-                            finalVArgs[i] = typeAsValue(targs[i].pos,
-                                                        targs[i].type,
-                                                        currentOwner,
-                                                        EENV);
-                        System.arraycopy(newVArgs, 0,
-                                         finalVArgs, targs.length,
-                                         newVArgs.length);
-                        return gen.mkApplyTV(tree.pos,
-                                             transform(fun),
-                                             targs,
-                                             finalVArgs);
-                    }
-                }
+                    Tree[] newVArgs = transform(vargs);
+                    Tree[] finalVArgs =
+                        new Tree[newVArgs.length + targs.length];
+                    for (int i = 0; i < targs.length; ++i)
+                        finalVArgs[i] = typeAsValue(targs[i].pos,
+                                                    targs[i].type,
+                                                    currentOwner,
+                                                    EENV);
+                    System.arraycopy(newVArgs, 0,
+                                     finalVArgs, targs.length,
+                                     newVArgs.length);
+                    return gen.mkApplyTV(tree.pos,
+                                         transform(fun),
+                                         targs,
+                                         finalVArgs);
+                } else
+                    return super.transform(tree);
 
             default:
                 return super.transform(tree);
@@ -508,8 +527,29 @@ public class TypesAsValuesPhase extends Phase {
                 rhs = Tree.Empty;
             else if (typSym.isClass())
                 rhs = scalaClassType(typSym.pos, typSym.type(), accSym, EENV);
-            else
-                rhs = typeAsValue(typSym.pos, typSym.type(), accSym, EENV);
+            else {
+                final Symbol[] vparams = accSym.valueParams();
+                final int pos = accSym.pos;
+
+                final HashMap varMap = new HashMap();
+                Symbol[] tparams = typSym.typeParams();
+                for (int i = 0; i < tparams.length; ++i)
+                    varMap.put(tparams[i], new Integer(i));
+
+                TEnv tEnv = new TEnv() {
+                        public boolean definesVar(Symbol sym) {
+                            return varMap.containsKey(sym);
+                        }
+
+                        public Tree treeForVar(Symbol sym) {
+                            int idx = ((Integer)varMap.get(sym)).intValue();
+                            Tree array = gen.mkLocalRef(pos, vparams[0]);
+                            return gen.mkArrayGet(pos, array, idx);
+                        }
+                    };
+
+                rhs = typeAsValue(typSym.pos, typSym.type(), accSym, tEnv);
+            }
             return gen.DefDef(accSym, rhs);
         }
 
@@ -546,12 +586,9 @@ public class TypesAsValuesPhase extends Phase {
                     ++zCount;
             }
 
+            Ancestor[][] disp = computeDisplay(clsSym);
             int[] displayCode = getDisplayCode(computeDisplay(clsSym));
 
-            Pair attrRef = refinements(clsSym.info());
-            int[] refinementCode =
-                refinementCode((ArrayList)attrRef.fst, (HashMap)attrRef.snd);
-
             Tree[] tcArgs = new Tree[] {
                 gen.mkIntLit(pos, level(clsSym)),
                 gen.mkStringLit(pos, prims.getJREClassName(clsSym)),
@@ -561,8 +598,8 @@ public class TypesAsValuesPhase extends Phase {
                 gen.mkIntLit(pos, zCount),
                 gen.mkIntLit(pos, mCount),
                 gen.mkIntLit(pos, pCount),
-                mkNewIntLitArray(pos, displayCode, owner),
-                mkNewIntLitArray(pos, refinementCode, owner)
+                gen.mkBooleanLit(pos, clsSym.parents()[0].symbol().isJava()),
+                mkNewIntLitArray(pos, displayCode, owner)
             };
 
             Symbol tcConst = defs.TYPECONSTRUCTOR_CLASS.primaryConstructor();
@@ -615,6 +652,13 @@ public class TypesAsValuesPhase extends Phase {
                               new Tree[] { gen.mkNullLit(pos) });
             Tree thenP = gen.mkLocalRef(pos, instVal);
 
+            Tree instFun =
+                gen.Select(pos,
+                           gen.mkLocalRef(pos, getTConstructorSym(clsSym)),
+                           defs.TYPECONSTRUCTOR_INSTANTIATE());
+            Tree[] instArgs = new Tree[] { gen.mkLocalRef(pos, vparams[0]) };
+            Tree instCall = gen.mkApply_V(pos, instFun, instArgs);
+
             final HashMap varMap = new HashMap();
             Symbol[] tparams = clsSym.typeParams();
             for (int i = 0; i < tparams.length; ++i)
@@ -649,21 +693,12 @@ public class TypesAsValuesPhase extends Phase {
                                                defs.SCALACLASSTYPE_TYPE(),
                                                parentTypes.toArray(),
                                                insSym);
-            Tree refArray = mkRefinementArray(pos,
-                                              refinements(clsSym.members()),
-                                              insSym,
-                                              tEnv);
 
-            Tree instFun =
-                gen.Select(pos,
-                           gen.mkLocalRef(pos, getTConstructorSym(clsSym)),
-                           defs.TYPECONSTRUCTOR_INSTANTIATE());
-            Tree[] instArgs = new Tree[] {
-                gen.mkLocalRef(pos, vparams[0]),
-                parentsArray,
-                refArray
-            };
-            Tree elseP = gen.mkApply_V(pos, instFun, instArgs);
+            Tree setParentsFun =
+                gen.Select(pos, instCall, defs.SCALACLASSTYPE_SETPARENTS());
+
+            Tree elseP =
+                gen.mkApply_V(pos, setParentsFun, new Tree[] { parentsArray });
 
             Tree ifExpr =
                 gen.If(pos, cond, thenP, elseP, defs.SCALACLASSTYPE_TYPE());
@@ -671,28 +706,6 @@ public class TypesAsValuesPhase extends Phase {
             return gen.DefDef(insSym, gen.mkBlock(pos, instValDef, ifExpr));
         }
 
-        private Tree mkRefinementArray(int pos,
-                                       ArrayList refinements,
-                                       Symbol owner,
-                                       TEnv env) {
-            TreeList refs = new TreeList();
-            Symbol refClass = defs.REFINEMENT_CLASS;
-
-            Iterator refIt = refinements.iterator();
-            while (refIt.hasNext()) {
-                Refinement ref = (Refinement)refIt.next();
-                Tree[] args = {
-                    gen.mkIntLit(pos, ref.hash),
-                    typeAsValue(pos, ref.type, owner, env)
-                };
-                Tree constr = gen.mkPrimaryConstructorGlobalRef(pos, refClass);
-                refs.append(gen.New(pos, gen.mkApply_V(constr, args)));
-            }
-
-            Type refType = defs.REFINEMENT_TYPE();
-            return gen.mkNewArray(pos, refType, refs.toArray(), owner);
-        }
-
         /**
          * Generate code to test if the given expression is an
          * instance of the given type.
@@ -733,6 +746,10 @@ public class TypesAsValuesPhase extends Phase {
             }
         }
 
+        private boolean isArrayClass(Symbol sym) {
+            return sym == defs.ARRAY_CLASS;
+        }
+
         /**
          * Transform a type into a tree representing it.
          */
@@ -745,10 +762,13 @@ public class TypesAsValuesPhase extends Phase {
                 if (env.definesVar(sym)) {
                     assert args.length == 0;
                     return env.treeForVar(sym);
-                } else if (basicTypes.containsKey(sym)) {
-                    return gen.mkGlobalRef(pos, (Symbol)basicTypes.get(sym));
+                } else if (isArrayClass(sym)) {
+                    assert args.length == 1;
+                    return arrayType(pos, sym, args[0], owner, env);
+                } else if (predefTypes.containsKey(sym)) {
+                    return gen.mkGlobalRef(pos, (Symbol)predefTypes.get(sym));
                 } else if (sym.isJava()) {
-                    assert args.length == 0
+                    assert args.length <= 1
                         : Debug.show(sym) + " " + args.length;
                     return javaType(pos, sym);
                 } else if (!sym.owner().isMethod()) {
@@ -762,19 +782,28 @@ public class TypesAsValuesPhase extends Phase {
                 }
 
             case SingleType(Type pre, Symbol sym):
-                return singleType(pos, pre, sym);
+                return singleType(pos, (Type.SingleType)tp);
 
             case CompoundType(Type[] parts, Scope members):
                 return compoundType(pos, parts, members, owner, env);
 
-            case MethodType(Symbol[] vparams, Type result):
-                return methodType(pos, vparams, result, owner, env);
-
             default:
                 throw Debug.abortIllegalCase(tp);
             }
         }
 
+        private Tree arrayType(int pos,
+                               Symbol sym,
+                               Type elemType,
+                               Symbol owner,
+                               TEnv env) {
+            Tree constr =
+                gen.mkPrimaryConstructorGlobalRef(pos,
+                                                  defs.JAVAREFARRAYTYPE_CLASS);
+            Tree[] args = new Tree[]{ typeAsValue(pos, elemType, owner, env) };
+            return gen.New(pos, gen.mkApply_V(constr, args));
+        }
+
         private Tree javaType(int pos, Symbol sym) {
             Tree constr =
                 gen.mkPrimaryConstructorGlobalRef(pos,
@@ -784,10 +813,10 @@ public class TypesAsValuesPhase extends Phase {
             return gen.New(pos, gen.mkApply_V(constr, args));
         }
 
-        private Tree singleType(int pos, Type pre, Symbol sym) {
+        private Tree singleType(int pos, Type.SingleType tp) {
             Tree constr =
                 gen.mkPrimaryConstructorGlobalRef(pos, defs.SINGLETYPE_CLASS);
-            Tree[] args = new Tree[] { gen.mkRef(pos, pre, sym) };
+            Tree[] args = new Tree[] { gen.mkQualifier(pos, tp) };
             return gen.New(pos, gen.mkApply_V(constr, args));
         }
 
@@ -800,15 +829,9 @@ public class TypesAsValuesPhase extends Phase {
             for (int i = 0; i < parts.length; ++i)
                 partsT[i] = typeAsValue(pos, parts[i], owner, env);
 
-            Tree refinementArray =
-                mkRefinementArray(pos,
-                                  (ArrayList)refinements(parts, members).fst,
-                                  owner,
-                                  env);
-
             Tree[] constrArgs = new Tree[] {
                 gen.mkNewArray(pos, defs.CLASSTYPE_TYPE(), partsT, owner),
-                refinementArray
+                gen.mkBooleanLit(pos, members.isEmpty())
             };
             Tree constr =
                 gen.mkPrimaryConstructorGlobalRef(pos,
@@ -821,7 +844,7 @@ public class TypesAsValuesPhase extends Phase {
             case TypeRef(Type pre, Symbol sym, Type[] args):
                 Symbol insSym = getInstMethSym(sym);
                 Tree preFun = isNestedClass(sym)
-                    ? gen.Select(pos, prefixAsValue(pos, pre), insSym)
+                    ? gen.Select(pos, gen.mkQualifier(pos, pre), insSym)
                     : gen.Ident(pos, insSym);
 
                 // TODO special case for monomorphic cases
@@ -844,24 +867,6 @@ public class TypesAsValuesPhase extends Phase {
             }
         }
 
-        private Tree methodType(int pos,
-                                Symbol[] args,
-                                Type result,
-                                Symbol owner,
-                                TEnv env) {
-            Tree[] argTypes = new Tree[args.length];
-            for (int i = 0; i < argTypes.length; ++i)
-                argTypes[i] = typeAsValue(pos, args[i].info(), owner, env);
-            Tree[] constrArgs = new Tree[] {
-                gen.mkNewArray(pos, defs.TYPE_TYPE(), argTypes, owner),
-                typeAsValue(pos, result, owner, env)
-            };
-            Tree constr =
-                gen.mkPrimaryConstructorGlobalRef(pos, defs.METHODTYPE_CLASS);
-
-            return gen.New(pos, gen.mkApply_V(constr, constrArgs));
-        }
-
         private final int VARIANT =
             Modifiers.COVARIANT | Modifiers.CONTRAVARIANT;
 
@@ -910,24 +915,6 @@ public class TypesAsValuesPhase extends Phase {
             }
         }
 
-        /**
-         * Transform a prefix into a tree representing it.
-         */
-        private Tree prefixAsValue(int pos, Type pre) {
-            assert isValuePrefix(pre);
-            switch (pre) {
-            case ThisType(Symbol clazz):
-                return gen.This(pos, clazz);
-            case SingleType(Type prefix, Symbol member):
-                return gen.mkApply__(pos,
-                                     gen.mkRef(pos,
-                                               prefixAsValue(pos, prefix),
-                                               member));
-            default:
-                throw Debug.abort("unexpected prefix", pre);
-            }
-        }
-
         private Ancestor[][] computeDisplay0(Symbol classSym) {
             Type[] parentTypes = classSym.parents();
 
@@ -959,7 +946,6 @@ public class TypesAsValuesPhase extends Phase {
                 if (parentSymbol.isJava())
                     continue;
 
-                ++parentIndex;
                 Ancestor[][] parentDisplay = computeDisplay(parentSymbol);
                 assert parentDisplay.length <= display.length;
 
@@ -981,6 +967,7 @@ public class TypesAsValuesPhase extends Phase {
                             myRow.add(new Ancestor(sym, parentIndex, i));
                     }
                 }
+                ++parentIndex;
             }
 
             Ancestor[][] finalDisplay = new Ancestor[level + 1][];
@@ -1035,119 +1022,6 @@ public class TypesAsValuesPhase extends Phase {
         }
     }
 
-    /*Pair<ArrayList<Refinement>, HashMap<Refinement,Origin>>*/
-    private Pair refinements(Type[] parents, Scope members) {
-        HashMap attribution = new HashMap();
-
-        ArrayList/*<Refinement>*/ ref = refinements(members);
-        attributeRefinements(attribution, ref, -1);
-
-        for (int i = parents.length; i > 0; --i) {
-            ArrayList parentRef =
-                (ArrayList)(refinements(parents[i - 1]).fst);
-            attributeRefinements(attribution, parentRef, i);
-            ref = mergeRefinements(parentRef, ref);
-        }
-
-        return new Pair(ref, attribution);
-    }
-
-    /*Pair<ArrayList<Refinement>, HashMap<Refinement,Origin>>*/
-    private Pair refinements(Type tp) {
-        return refinements(tp.parents(), tp.members());
-    }
-
-    /** Return the refinements introduced by the given members */
-    private ArrayList/*<Refinement>*/ refinements(Scope members) {
-        ArrayList/*<Refinement>*/ myRefs = new ArrayList();
-        Scope.SymbolIterator membersIt = members.iterator();
-        while (membersIt.hasNext()) {
-            Symbol mem = membersIt.next();
-            Symbol origMem = originalSymbol(mem);
-            if (origMem != Symbol.NONE) {
-                Type ownerTp = mem.owner().thisType();
-                Type origTp = ownerTp.memberType(origMem);
-                Type memTp = ownerTp.memberType(mem);
-
-                if (!memTp.isSameAs(origTp))
-                    myRefs.add(new Refinement(origMem, mem.info()));
-            }
-        }
-        Collections.sort(myRefs);
-        return myRefs;
-    }
-
-    private ArrayList mergeRefinements(ArrayList rs1, ArrayList rs2) {
-        ArrayList/*<Refinement>*/ res =
-            new ArrayList(rs1.size() + rs2.size());
-
-        int i1 = 0, i2 = 0;
-        while (i1 < rs1.size() && i2 < rs2.size()) {
-            Refinement r1 = (Refinement)rs1.get(i1);
-            Refinement r2 = (Refinement)rs2.get(i2);
-            int cmp = r1.compareTo(r2);
-            if (cmp < 0) {
-                res.add(r1);
-                ++i1;
-            } else if (cmp > 0) {
-                res.add(r2);
-                ++i2;
-            } else {
-                assert r2.type.isSubType(r1.type) : r2 + " !<: " + r1;
-                res.add(r2);
-                ++i1;
-                ++i2;
-            }
-        }
-        while (i1 < rs1.size())
-            res.add(rs1.get(i1++));
-        while (i2 < rs2.size())
-            res.add(rs2.get(i2++));
-
-        return res;
-    }
-
-    private void attributeRefinements(HashMap attribution,
-                                      ArrayList refs,
-                                      int parentIndex) {
-        for (int i = 0; i < refs.size(); ++i)
-            attribution.put(refs.get(i), new Origin(parentIndex, i));
-    }
-
-    private int[] refinementCode(ArrayList refinement, HashMap attribution) {
-        int[] code = new int[1 + 2 * refinement.size()];
-        int pc = 0;
-
-        code[pc++] = refinement.size();
-        Iterator refIt = refinement.iterator();
-        while (refIt.hasNext()) {
-            Origin orig = (Origin)attribution.get(refIt.next());
-            code[pc++] = orig.parentIndex;
-            code[pc++] = orig.position;
-        }
-        assert pc == code.length;
-
-        return code;
-    }
-
-//     private Symbol originalSymbol(Symbol sym) {
-//         Symbol orig = originalSymbol0(sym);
-//         if (orig != Symbol.NONE)
-//         System.out.println("orig for " + Debug.show(sym) + ": " + Debug.show(orig));
-//         return orig;
-//     }
-
-    private Symbol originalSymbol(Symbol sym) {
-        Type[] closure = sym.owner().closure();
-        for (int i = closure.length; i > 0; --i) {
-            Type parent = closure[i - 1];
-            Symbol maybeOrig = sym.overriddenSymbol(parent, false);
-            if (maybeOrig != Symbol.NONE)
-                return maybeOrig;
-        }
-        return Symbol.NONE;
-    }
-
     //////////////////////////////////////////////////////////////////////
 
     private static class TEnv {
@@ -1192,58 +1066,4 @@ public class TypesAsValuesPhase extends Phase {
             this.position = position;
         }
     }
-
-    private static class Origin {
-        public final int parentIndex;
-        public final int position;
-        public Origin(int parentIndex, int position) {
-            this.parentIndex = parentIndex;
-            this.position = position;
-        }
-    }
-
-    private static class Pair {
-        public final Object fst, snd;
-        public Pair(Object fst, Object snd) {
-            this.fst = fst;
-            this.snd = snd;
-        }
-    }
-
-    private class Refinement implements Comparable {
-        public final Symbol member;
-        public final int hash;
-        public final Type type;
-
-        private final SymbolNameWriter symWriter = new SymbolNameWriter();
-
-        public Refinement(Symbol member, Type type) {
-            this.member = member;
-            this.hash = memberHash(member);
-            this.type = type;
-        }
-
-        public boolean equals(Object thatO) {
-            return (thatO instanceof Refinement) && (compareTo(thatO) == 0);
-        }
-
-        public int compareTo(Object thatO) {
-            Refinement that = (Refinement)thatO;
-            if (this.hash < that.hash)
-                return -1;
-            else if (this.hash > that.hash)
-                return 1;
-            else
-                return 0;
-        }
-
-        public String toString() {
-            return "<" + hash + " " + member + " : " + type + ">";
-        }
-
-        private int memberHash(Symbol sym) {
-            // TODO use FNV hash
-            return symWriter.toString(sym).hashCode();
-        }
-    }
 }