- Modified erasure to use unbox and x2x methods...

- Modified erasure to use unbox and x2x methods instead of asX methods

2 files changed, 49 insertions, 29 deletions

diff --git a/sources/scalac/backend/Primitives.java b/sources/scalac/backend/Primitives.java
index c21304de22..0867106282 100644
--- a/sources/scalac/backend/Primitives.java
+++ b/sources/scalac/backend/Primitives.java
@@ -999,15 +999,15 @@ public class Primitives {
     /** Return unbox method returning values of the given kind. */
     public Symbol getUnboxValueSymbol(int kind) {
         switch (kind) {
-        case TypeTags.UNIT   : return AS_UVALUE;
-        case TypeTags.BOOLEAN: return AS_ZVALUE;
-        case TypeTags.BYTE   : return AS_BVALUE;
-        case TypeTags.SHORT  : return AS_SVALUE;
-        case TypeTags.CHAR   : return AS_CVALUE;
-        case TypeTags.INT    : return AS_IVALUE;
-        case TypeTags.LONG   : return AS_LVALUE;
-        case TypeTags.FLOAT  : return AS_FVALUE;
-        case TypeTags.DOUBLE : return AS_DVALUE;
+        case TypeTags.UNIT   : return UNBOX_UVALUE;
+        case TypeTags.BOOLEAN: return UNBOX_ZVALUE;
+        case TypeTags.BYTE   : return UNBOX_BVALUE;
+        case TypeTags.SHORT  : return UNBOX_SVALUE;
+        case TypeTags.CHAR   : return UNBOX_CVALUE;
+        case TypeTags.INT    : return UNBOX_IVALUE;
+        case TypeTags.LONG   : return UNBOX_LVALUE;
+        case TypeTags.FLOAT  : return UNBOX_FVALUE;
+        case TypeTags.DOUBLE : return UNBOX_DVALUE;
         default              : throw Debug.abort("illegal kind " + kind);
         }
     }
@@ -1018,21 +1018,21 @@ public class Primitives {
         case UnboxedType(int kind):
             return getUnboxArraySymbol(kind);
         default:
-            return AS_OARRAY;
+            return UNBOX_OARRAY;
         }
     }
 
     /** Return unbox method returning arrays of elements of the given kind. */
     public Symbol getUnboxArraySymbol(int kind) {
         switch (kind) {
-        case TypeTags.BOOLEAN: return AS_ZARRAY;
-        case TypeTags.BYTE   : return AS_BARRAY;
-        case TypeTags.SHORT  : return AS_SARRAY;
-        case TypeTags.CHAR   : return AS_CARRAY;
-        case TypeTags.INT    : return AS_IARRAY;
-        case TypeTags.LONG   : return AS_LARRAY;
-        case TypeTags.FLOAT  : return AS_FARRAY;
-        case TypeTags.DOUBLE : return AS_DARRAY;
+        case TypeTags.BOOLEAN: return UNBOX_ZARRAY;
+        case TypeTags.BYTE   : return UNBOX_BARRAY;
+        case TypeTags.SHORT  : return UNBOX_SARRAY;
+        case TypeTags.CHAR   : return UNBOX_CARRAY;
+        case TypeTags.INT    : return UNBOX_IARRAY;
+        case TypeTags.LONG   : return UNBOX_LARRAY;
+        case TypeTags.FLOAT  : return UNBOX_FARRAY;
+        case TypeTags.DOUBLE : return UNBOX_DARRAY;
         default              : throw Debug.abort("illegal kind " + kind);
         }
     }
diff --git a/sources/scalac/transformer/Erasure.java b/sources/scalac/transformer/Erasure.java
index 28382c738c..660f977d7f 100644
--- a/sources/scalac/transformer/Erasure.java
+++ b/sources/scalac/transformer/Erasure.java
@@ -301,20 +301,35 @@ public class Erasure extends GenTransformer implements Modifiers {
 
     /** Coerces the given tree to the given type. */
     private Tree coerce(Tree tree, Type pt) {
-        if (isSubType(tree.getType(), pt)) {
-            if (tree.getType().symbol() == definitions.ARRAY_CLASS) {
+        if (isSubType(tree.type(), pt)) {
+            if (tree.type().symbol() == definitions.ARRAY_CLASS) {
                 if (pt.symbol() != definitions.ARRAY_CLASS) {
-                    Symbol symbol = primitives.AS__ARRAY;
-                    return coerce(gen.mkApply__(gen.Select(tree, symbol)), pt);
+                    Symbol symbol = primitives.UNBOX__ARRAY;
+                    Tree unboxtree = gen.mkRef(tree.pos, symbol);
+                    tree = gen.mkApply_V(unboxtree, new Tree[] {tree});
+                    return coerce(tree, pt);
                 }
             }
             return tree;
         }
-        if (isUnboxedType(tree.getType())) {
-            if (!isUnboxedType(pt)) return coerce(box(tree), pt);
-        } else if (isUnboxedType(pt)) {
-            if (tree.type.symbol() == definitions.ARRAY_CLASS
-                || isUnboxedSimpleType(pt)) return unbox(tree, pt);
+        if (isUnboxedSimpleType(tree.type())) {
+            if (isUnboxedSimpleType(pt)) return convert(tree, pt);
+            Type to = pt.erasure();
+            if (!isUnboxedSimpleType(to) || to.isSameAs(tree.type()))
+                return box(tree);
+            else
+                return coerce(convert(tree, to), pt);
+        } else if (isUnboxedArrayType(tree.type())) {
+            if (!isUnboxedArrayType(pt)) return coerce(box(tree), pt);
+        } else if (isUnboxedSimpleType(pt)) {
+            Type from = tree.type().erasure();
+            if (isUnboxedSimpleType(from))
+                return convert(unbox(tree, from), pt);
+            else
+                return unbox(coerce(tree, boxUnboxedType(pt)), pt);
+        } else if (isUnboxedArrayType(pt)) {
+            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);
             return gen.mkApply_V(boxtree, new Tree[]{tree});
@@ -334,8 +349,13 @@ public class Erasure extends GenTransformer implements Modifiers {
     /** Unboxes the given tree to the given type. */
     private Tree unbox(Tree tree, Type pt) {
         Symbol symbol = primitives.getUnboxValueSymbol(pt);
-        tree = coerce(tree, symbol.owner().nextType());
-        return gen.mkApply__(gen.Select(tree, symbol));
+        return gen.mkApply_V(gen.mkRef(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});
     }
 
     //########################################################################