- Moved erasure of superclasses of interfaces f...

- Moved erasure of superclasses of interfaces from AddInterfaces into
Erasure

2 files changed, 31 insertions, 18 deletions

diff --git a/sources/scalac/transformer/AddInterfacesPhase.java b/sources/scalac/transformer/AddInterfacesPhase.java
index fec5d87a80..2536a4bc1d 100644
--- a/sources/scalac/transformer/AddInterfacesPhase.java
+++ b/sources/scalac/transformer/AddInterfacesPhase.java
@@ -40,7 +40,8 @@ public class AddInterfacesPhase extends Phase {
             // removed.
             return removeValueParams(tp);
         } else if (sym.isClass() && !sym.isJava()) {
-            Definitions definitions = Global.instance.definitions;
+            Definitions definitions = global.definitions;
+            if (sym == definitions.ANY_CLASS) return tp;
             Type[] oldParents = tp.parents();
             assert oldParents.length > 0 : Debug.show(sym);
             for (int i = 1; i < oldParents.length; ++i) {
@@ -81,17 +82,7 @@ public class AddInterfacesPhase extends Phase {
                     newMembers.enterOrOverload(member);
                 }
 
-                Symbol oldSym = oldParents[0].symbol();
-                if (oldSym.isJava()
-                    && !oldSym.isInterface()
-                    && oldSym != definitions.ANY_CLASS
-                    && oldSym != definitions.ANYREF_CLASS) {
-                    newParents = new Type[oldParents.length];
-                    newParents[0] = definitions.ANYREF_TYPE();
-                    for (int i = 1; i < oldParents.length; ++i)
-                        newParents[i] = oldParents[i];
-                } else
-                    newParents = oldParents;
+                newParents = oldParents;
             } else {
                 // The symbol is the one of a class which doesn't need
                 // an interface. We need to fix its parents to use
@@ -161,10 +152,10 @@ public class AddInterfacesPhase extends Phase {
                  || classSym.isModuleClass()
                  || classSym.isAnonymousClass()
                  || hasInterfaceSymbol(classSym)
-                 || classSym == Global.instance.definitions.ANY_CLASS
-                 || classSym == Global.instance.definitions.ANYREF_CLASS
-                 || classSym == Global.instance.definitions.ALL_CLASS
-                 || classSym == Global.instance.definitions.ALLREF_CLASS);
+                 || classSym == global.definitions.ANY_CLASS
+                 || classSym == global.definitions.ANYREF_CLASS
+                 || classSym == global.definitions.ALL_CLASS
+                 || classSym == global.definitions.ALLREF_CLASS);
     }
 
     protected final static String CLASS_SUFFIX = "$class";
diff --git a/sources/scalac/transformer/ErasurePhase.java b/sources/scalac/transformer/ErasurePhase.java
index d823bd46ce..9d423d282b 100644
--- a/sources/scalac/transformer/ErasurePhase.java
+++ b/sources/scalac/transformer/ErasurePhase.java
@@ -21,6 +21,7 @@ import scalac.checkers.CheckSymbols;
 import scalac.checkers.CheckTypes;
 import scalac.checkers.CheckNames;
 import scalac.symtab.Definitions;
+import scalac.symtab.Scope;
 import scalac.symtab.Symbol;
 import scalac.symtab.Type;
 import scalac.util.Debug;
@@ -52,9 +53,30 @@ public class ErasurePhase extends Phase {
     }
 
     public Type transformInfo(Symbol sym, Type tp) {
-        if (sym.isClass() && sym.isSubClass(definitions.ANYVAL_CLASS) && sym != definitions.ANYVAL_CLASS) return tp;
         if (sym.isConstructor() && sym.constructorClass().isSubClass(definitions.ANYVAL_CLASS)) return tp;
-        if (sym.isClass()) return Type.erasureMap.map(tp);
+        if (sym.isClass()) {
+            if (sym == definitions.ANY_CLASS) return tp;
+            if (sym.isJava() && sym.isModuleClass()) return tp;
+            if (sym.isSubClass(definitions.ANYVAL_CLASS))
+                if (sym != definitions.ANYVAL_CLASS) return tp;
+            switch (tp) {
+            case CompoundType(Type[] parents, Scope members):
+                assert parents.length != 0: Debug.show(sym) + " -- " + tp;
+                if (sym.isInterface()) {
+                    Symbol superclass = parents[0].symbol();
+                    if (superclass.isJava() && !superclass.isInterface()) {
+                        if (superclass != definitions.ANY_CLASS) {
+                            parents = Type.cloneArray(parents);
+                            parents[0] = definitions.ANYREF_TYPE();
+                            tp = Type.compoundType(parents, members, sym);
+                        }
+                    }
+                }
+                return Type.erasureMap.map(tp);
+            default:
+                throw Debug.abort("illegal case", tp);
+            }
+        }
         if (sym.isType()) return tp;
         // if (sym == definitions.NULL) return tp.resultType().erasure();
         switch (primitives.getPrimitive(sym)) {