From 1e46957a4f69c0387e5098e9839f670f5201a79e Mon Sep 17 00:00:00 2001 From: paltherr Date: Thu, 30 Oct 2003 17:16:04 +0000 Subject: - Fixed, in Definitions, type of primitive type... - Fixed, in Definitions, type of primitive types and array types after erasure --- sources/scala/tools/scalai/Interpreter.java | 7 +- sources/scalac/backend/Primitives.java | 3 +- sources/scalac/symtab/Definitions.java | 86 +++++++++++++++++++--- .../scalac/symtab/classfile/JavaTypeCreator.java | 4 +- sources/scalac/transformer/ErasurePhase.java | 2 +- sources/scalac/typechecker/Analyzer.java | 14 ++-- 6 files changed, 91 insertions(+), 25 deletions(-) (limited to 'sources') 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 */ @@ -351,6 +377,20 @@ public class Definitions { /** The universal pattern */ 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 @@ -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); -- cgit v1.2.3