- Fixed, in Definitions, type of primitive type...

- Fixed, in Definitions, type of primitive types and array types after
erasure

6 files changed, 91 insertions, 25 deletions

diff --git a/sources/scala/tools/scalai/Interpreter.java b/sources/scala/tools/scalai/Interpreter.java
index 381820895e..8314696c0a 100644
--- a/sources/scala/tools/scalai/Interpreter.java
+++ b/sources/scala/tools/scalai/Interpreter.java
@@ -10,6 +10,7 @@
 package scalai;
 
 import scalac.Global;
+import scalac.Phase;
 import scalac.symtab.Definitions;
 import scalac.symtab.Symbol;
 import scalac.symtab.TermSymbol;
@@ -142,16 +143,14 @@ public class Interpreter {
     // Private Methods - Finding main method
 
     private Type getMainMethodType(boolean erased) {
-        scalac.Phase current = global.currentPhase; // !!!
+        Phase current = global.currentPhase;
         if (!erased) global.currentPhase = global.getFirstPhase();
         Definitions definitions = global.definitions;
         Type argument = definitions.ARRAY_TYPE(definitions.JAVA_STRING_TYPE());
         Type result = definitions.UNIT_TYPE();
-        if (erased) argument = argument.erasure();
-        if (erased) result = result.fullErasure();
         Symbol formal = new TermSymbol(0, ARGS_N, null, Modifiers.PARAM);
         formal.setInfo(argument);
-        if (!erased) global.currentPhase = current;
+        global.currentPhase = current;
         return Type.MethodType(new Symbol[] {formal}, result);
     }
 
diff --git a/sources/scalac/backend/Primitives.java b/sources/scalac/backend/Primitives.java
index a48be3a333..c636cc66a7 100644
--- a/sources/scalac/backend/Primitives.java
+++ b/sources/scalac/backend/Primitives.java
@@ -319,7 +319,8 @@ public class Primitives {
     }
 
     private Symbol getBoxArray(Symbol[] alts, Type type) {
-        return getBoxValue(alts, definitions.ARRAY_TYPE(type));
+        Type array = definitions.ARRAY_CLASS.type();
+        return getBoxValue(alts, Type.appliedType(array, new Type[]{type}));
     }
 
     private Symbol getUniqueTerm(Symbol owner, Name name) {
diff --git a/sources/scalac/symtab/Definitions.java b/sources/scalac/symtab/Definitions.java
index 547c998e1f..256a91a2e0 100644
--- a/sources/scalac/symtab/Definitions.java
+++ b/sources/scalac/symtab/Definitions.java
@@ -69,39 +69,57 @@ public class Definitions {
 
     /** The scala.Unit class */
     public final Symbol UNIT_CLASS;
-    public final Type   UNIT_TYPE() {return UNIT_CLASS.type();}
+    public final Type   UNIT_TYPE() {
+        return UNIT_TYPE.type().resultType();
+    }
 
     /** The scala.Boolean class */
     public final Symbol BOOLEAN_CLASS;
-    public final Type   BOOLEAN_TYPE() {return BOOLEAN_CLASS.type();}
+    public final Type   BOOLEAN_TYPE() {
+        return BOOLEAN_TYPE.type().resultType();
+    }
 
     /** The scala.Byte class */
     public final Symbol BYTE_CLASS;
-    public final Type   BYTE_TYPE() {return BYTE_CLASS.type();}
+    public final Type   BYTE_TYPE() {
+        return BYTE_TYPE.type().resultType();
+    }
 
     /** The scala.Short class */
     public final Symbol SHORT_CLASS;
-    public final Type   SHORT_TYPE() {return SHORT_CLASS.type();}
+    public final Type   SHORT_TYPE() {
+        return SHORT_TYPE.type().resultType();
+    }
 
     /** The scala.Char class */
     public final Symbol CHAR_CLASS;
-    public final Type   CHAR_TYPE() {return CHAR_CLASS.type();}
+    public final Type   CHAR_TYPE() {
+        return CHAR_TYPE.type().resultType();
+    }
 
     /** The scala.Int class */
     public final Symbol INT_CLASS;
-    public final Type   INT_TYPE() {return INT_CLASS.type();}
+    public final Type   INT_TYPE() {
+        return INT_TYPE.type().resultType();
+    }
 
     /** The scala.Long class */
     public final Symbol LONG_CLASS;
-    public final Type   LONG_TYPE() {return LONG_CLASS.type();}
+    public final Type   LONG_TYPE() {
+        return LONG_TYPE.type().resultType();
+    }
 
     /** The scala.Float class */
     public final Symbol FLOAT_CLASS;
-    public final Type   FLOAT_TYPE() {return FLOAT_CLASS.type();}
+    public final Type   FLOAT_TYPE() {
+        return FLOAT_TYPE.type().resultType();
+    }
 
     /** The scala.Double class */
     public final Symbol DOUBLE_CLASS;
-    public final Type   DOUBLE_TYPE() {return DOUBLE_CLASS.type();}
+    public final Type   DOUBLE_TYPE() {
+        return DOUBLE_TYPE.type().resultType();
+    }
 
     //########################################################################
     // Public Fields & Methods - Scala reference classes
@@ -171,7 +189,15 @@ public class Definitions {
     /** The scala.Array class */
     public final Symbol ARRAY_CLASS;
     public final Type   ARRAY_TYPE(Type element) {
-        return getType(ARRAY_CLASS, element);
+        Type type = ARRAY_TYPE.type().resultType();
+        switch (type) {
+        case TypeRef(Type prefix, Symbol clasz, _):
+            return Type.TypeRef(prefix, clasz, new Type[]{element});
+        case UnboxedArrayType(_):
+            return Type.UnboxedArrayType(element);
+        default:
+            throw Debug.abort("illegal case", type);
+        }
     }
 
     /** The scala.MatchError module */
@@ -352,6 +378,20 @@ public class Definitions {
     public final Symbol PATTERN_WILDCARD;
 
     //########################################################################
+    // Private Fields - Symbol
+
+    private final Symbol UNIT_TYPE;
+    private final Symbol BOOLEAN_TYPE;
+    private final Symbol BYTE_TYPE;
+    private final Symbol SHORT_TYPE;
+    private final Symbol CHAR_TYPE;
+    private final Symbol INT_TYPE;
+    private final Symbol LONG_TYPE;
+    private final Symbol FLOAT_TYPE;
+    private final Symbol DOUBLE_TYPE;
+    private final Symbol ARRAY_TYPE;
+
+    //########################################################################
     // Public Constructor
 
     /** Initializes this instance. */
@@ -417,6 +457,30 @@ public class Definitions {
         initClass(ALL_CLASS, new Type[]{ANY_TYPE()});
         initAlias(STRING_CLASS, JAVA_STRING_TYPE());
 
+        // create type symbols
+        UNIT_TYPE    = newTerm(Symbol.NONE, Names.Unit   , 0);
+        BOOLEAN_TYPE = newTerm(Symbol.NONE, Names.Boolean, 0);
+        BYTE_TYPE    = newTerm(Symbol.NONE, Names.Byte   , 0);
+        SHORT_TYPE   = newTerm(Symbol.NONE, Names.Short  , 0);
+        CHAR_TYPE    = newTerm(Symbol.NONE, Names.Char   , 0);
+        INT_TYPE     = newTerm(Symbol.NONE, Names.Int    , 0);
+        LONG_TYPE    = newTerm(Symbol.NONE, Names.Long   , 0);
+        FLOAT_TYPE   = newTerm(Symbol.NONE, Names.Float  , 0);
+        DOUBLE_TYPE  = newTerm(Symbol.NONE, Names.Double , 0);
+        ARRAY_TYPE   = newTerm(Symbol.NONE, Names.Array  , 0);
+
+        initMethod(UNIT_TYPE   , Type.EMPTY_ARRAY, UNIT_CLASS.type());
+        initMethod(BOOLEAN_TYPE, Type.EMPTY_ARRAY, BOOLEAN_CLASS.type());
+        initMethod(BYTE_TYPE   , Type.EMPTY_ARRAY, BYTE_CLASS.type());
+        initMethod(SHORT_TYPE  , Type.EMPTY_ARRAY, SHORT_CLASS.type());
+        initMethod(CHAR_TYPE   , Type.EMPTY_ARRAY, CHAR_CLASS.type());
+        initMethod(INT_TYPE    , Type.EMPTY_ARRAY, INT_CLASS.type());
+        initMethod(LONG_TYPE   , Type.EMPTY_ARRAY, LONG_CLASS.type());
+        initMethod(FLOAT_TYPE  , Type.EMPTY_ARRAY, FLOAT_CLASS.type());
+        initMethod(DOUBLE_TYPE , Type.EMPTY_ARRAY, DOUBLE_CLASS.type());
+        initMethod(ARRAY_TYPE  , Type.EMPTY_ARRAY,
+            Type.appliedType(ARRAY_CLASS.type(), new Type[]{ANYREF_TYPE()}));
+
         // add members to scala.Any
 	ANY_EQ       = newTerm(ANY_CLASS, Names.eq          , 0);
         ANY_EQEQ     = newTerm(ANY_CLASS, Names.EQEQ        , Modifiers.FINAL);
@@ -596,7 +660,7 @@ public class Definitions {
 
     /** Returns the type of given class applied to given type arguments. */
     private Type getType(Symbol clasz, Type[] args) {
-        return Type.appliedType(clasz.typeConstructor(), args);
+        return Type.appliedType(clasz.type(), args);
     }
 
     //########################################################################
diff --git a/sources/scalac/symtab/classfile/JavaTypeCreator.java b/sources/scalac/symtab/classfile/JavaTypeCreator.java
index 0e5653f9e1..09f86d8af5 100644
--- a/sources/scalac/symtab/classfile/JavaTypeCreator.java
+++ b/sources/scalac/symtab/classfile/JavaTypeCreator.java
@@ -28,6 +28,7 @@ public class JavaTypeCreator implements JavaTypeFactory {
     protected final Type BYTE_TYPE;
     protected final Type BOOLEAN_TYPE;
     protected final Type UNIT_TYPE;
+    protected final Type ARRAY_TYPE;
     protected final Type JAVA_OBJECT_TYPE;
 
     public JavaTypeCreator(Definitions definitions) {
@@ -42,6 +43,7 @@ public class JavaTypeCreator implements JavaTypeFactory {
         this.BYTE_TYPE = definitions.BYTE_CLASS.typeConstructor();
         this.BOOLEAN_TYPE = definitions.BOOLEAN_CLASS.typeConstructor();
         this.UNIT_TYPE = definitions.UNIT_CLASS.typeConstructor();
+        this.ARRAY_TYPE = definitions.ARRAY_CLASS.typeConstructor();
         this.JAVA_OBJECT_TYPE =definitions.JAVA_OBJECT_CLASS.typeConstructor();
     }
 
@@ -90,7 +92,7 @@ public class JavaTypeCreator implements JavaTypeFactory {
     }
 
     public Type arrayType(Type elemtpe) {
-        return definitions.ARRAY_TYPE(elemtpe);
+        return Type.appliedType(ARRAY_TYPE, new Type[]{elemtpe});
     }
 
     public Type methodType(Type[] argtpes, Type restpe, Type[] thrown) {
diff --git a/sources/scalac/transformer/ErasurePhase.java b/sources/scalac/transformer/ErasurePhase.java
index 0e89618dec..d823bd46ce 100644
--- a/sources/scalac/transformer/ErasurePhase.java
+++ b/sources/scalac/transformer/ErasurePhase.java
@@ -52,7 +52,7 @@ public class ErasurePhase extends Phase {
     }
 
     public Type transformInfo(Symbol sym, Type tp) {
-        if (sym.isClass() && sym.isSubClass(definitions.DOUBLE_CLASS)) return 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.isType()) return tp;
diff --git a/sources/scalac/typechecker/Analyzer.java b/sources/scalac/typechecker/Analyzer.java
index b3cdccee72..4b9e4c0f19 100644
--- a/sources/scalac/typechecker/Analyzer.java
+++ b/sources/scalac/typechecker/Analyzer.java
@@ -1860,7 +1860,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 			Tree.Template templ1 = copy.Template(templ, parents, body1);
 			templ1.setType(Type.NoType).setSymbol(Symbol.NONE);
 			return copy.PackageDef(tree, pkg, templ1)
-			    .setType(definitions.UNIT_TYPE());
+			    .setType(Type.NoType);
 		    }
 		}
 		return tree.setType(Type.ErrorType);
@@ -1880,7 +1880,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		checkNoEscape(tree.pos, sym.info());
 		popContext();
 		return copy.ClassDef(tree, sym, tparams1, vparams1, tpe1, templ1)
-		    .setType(definitions.UNIT_TYPE());
+		    .setType(Type.NoType);
 
 	    case ModuleDef(_, _, Tree tpe, Tree.Template templ):
 		sym.moduleClass().initialize();
@@ -1890,7 +1890,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		    error(tree.pos,
 			sym + " does not implement " + tpe1.type);
 		return copy.ModuleDef(tree, sym, tpe1, templ1)
-		    .setType(definitions.UNIT_TYPE());
+		    .setType(Type.NoType);
 
 	    case DefDef(_, Name name, Tree.AbsTypeDef[] tparams, Tree.ValDef[][] vparams, Tree tpe, Tree rhs):
 		pushContext(tree, sym, new Scope(context.scope));
@@ -1916,7 +1916,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		checkNonCyclic(tree.pos, tpe1.type);
 		sym.flags &= ~LOCKED;
 		return copy.DefDef(tree, sym, tparams1, vparams1, tpe1, rhs1)
-		    .setType(definitions.UNIT_TYPE());
+		    .setType(Type.NoType);
 
 	    case ValDef(_, _, Tree tpe, Tree rhs):
 		Tree tpe1 = (tpe == Tree.Empty)
@@ -1934,14 +1934,14 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		checkNonCyclic(tree.pos, tpe1.type);
 		sym.flags &= ~LOCKED;
 		return copy.ValDef(tree, sym, tpe1, rhs1)
-		    .setType(definitions.UNIT_TYPE());
+		    .setType(Type.NoType);
 
 	    case AbsTypeDef(_, _, Tree rhs, Tree lobound):
 		Tree rhs1 = transform(rhs, TYPEmode);
 		Tree lobound1 = transform(lobound, TYPEmode);
 		checkNonCyclic(tree.pos, sym.type());
 		return copy.AbsTypeDef(tree, sym, rhs1, lobound1)
-		    .setType(definitions.UNIT_TYPE());
+		    .setType(Type.NoType);
 
 	    case AliasTypeDef(_, _, AbsTypeDef[] tparams, Tree rhs):
 		pushContext(tree, sym.primaryConstructor(), new Scope(context.scope));
@@ -1951,7 +1951,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		popContext();
 		checkNonCyclic(tree.pos, sym.type());
 		return copy.AliasTypeDef(tree, sym, tparams1, rhs1)
-		    .setType(definitions.UNIT_TYPE());
+		    .setType(Type.NoType);
 
 	    case Import(Tree expr, Name[] selectors):
 		context.imports = new ImportList(tree, context.scope, context.imports);