From fb814bd99236d100b74978cb357ab42ffb2c79a8 Mon Sep 17 00:00:00 2001 From: paltherr Date: Thu, 30 Oct 2003 12:49:30 +0000 Subject: - Normalized member names of class Definition - Cleaned code of Definition --- sources/scala/tools/scalai/Compiler.java | 44 +- sources/scala/tools/scalai/ExpressionCompiler.java | 4 +- sources/scala/tools/scalai/Interpreter.java | 2 +- sources/scalac/ast/TreeGen.java | 12 +- sources/scalac/backend/Primitives.java | 22 +- sources/scalac/backend/jvm/GenJVM.java | 4 +- sources/scalac/backend/msil/GenMSIL.java | 8 +- sources/scalac/symtab/Definitions.java | 742 +++++++++++---------- .../scalac/symtab/classfile/JavaTypeCreator.java | 2 +- sources/scalac/transformer/Erasure.java | 4 +- sources/scalac/transformer/LambdaLiftPhase.java | 2 +- sources/scalac/transformer/UnCurry.java | 6 +- sources/scalac/transformer/UnCurryPhase.java | 2 +- .../scalac/transformer/matching/CodeFactory.java | 8 +- .../transformer/matching/LeftTracerInScala.java | 6 +- .../scalac/transformer/matching/PatternTool.java | 10 - .../transformer/matching/RightTracerInScala.java | 4 +- sources/scalac/typechecker/Analyzer.java | 10 +- sources/scalac/typechecker/DeSugarize.java | 2 +- sources/scalac/typechecker/Infer.java | 2 +- sources/scalac/typechecker/RefCheck.java | 12 +- 21 files changed, 458 insertions(+), 450 deletions(-) diff --git a/sources/scala/tools/scalai/Compiler.java b/sources/scala/tools/scalai/Compiler.java index 4474d641bc..b3d32548a8 100644 --- a/sources/scala/tools/scalai/Compiler.java +++ b/sources/scala/tools/scalai/Compiler.java @@ -63,10 +63,10 @@ public class Compiler { SourceFile compiled = new SourceFile("<>", new byte[0]); - environment.insertFunction(definitions.STRING_PLUS_ANY, Function.StringPlus); // !!! + environment.insertFunction(definitions.JAVA_STRING_PLUS, Function.StringPlus); // !!! // !!! ANY_PLUS_STRING is commented out in definitions // !!! environment.insertFunction(definitions.ANY_PLUS_STRING, Function.StringPlus); // !!! - environment.insertFunction(definitions.THROW, Function.Throw); + environment.insertFunction(definitions.JAVA_THROWABLE_THROW, Function.Throw); // !!! environment.insertFunction(definitions.MATCH, ...); // !!! environment.insertFunction(definitions.IS, ...); // !!! environment.insertFunction(definitions.AS, ...); @@ -110,13 +110,13 @@ public class Compiler { Code.Null, Variable.Argument(0))}, 0), 0)); - any_methods.put(definitions.EQUALS, equals_code); + any_methods.put(definitions.ANY_EQUALS, equals_code); any_methods.put(equals_method, equals_code); - environment.insertFunction(definitions.EQUALS, + environment.insertFunction(definitions.ANY_EQUALS, Function.JavaMethod(equals_method)); Override equals_override = Override.empty(); - equals_override.insert(equals_method).insert(definitions.EQUALS); - environment.insertOverride(definitions.EQUALS, equals_override); + equals_override.insert(equals_method).insert(definitions.ANY_EQUALS); + environment.insertOverride(definitions.ANY_EQUALS, equals_override); // !!! method java.lang.Object.equals(Object) // !!! method java.lang.Object.finalize() @@ -131,18 +131,18 @@ public class Compiler { CodePromise hashCode_code = new CodePromise( new CodeContainer( compiled, - definitions.HASHCODE, + definitions.ANY_HASHCODE, Code.Invoke( Code.Self, Function.HashCode, new Code[0], 0), 0)); - any_methods.put(definitions.HASHCODE, hashCode_code); + any_methods.put(definitions.ANY_HASHCODE, hashCode_code); any_methods.put(hashCode_method, hashCode_code); - environment.insertFunction(definitions.HASHCODE, + environment.insertFunction(definitions.ANY_HASHCODE, Function.JavaMethod(hashCode_method)); Override hashCode_override = Override.empty(); - hashCode_override.insert(hashCode_method).insert(definitions.HASHCODE); - environment.insertOverride(definitions.HASHCODE, hashCode_override); + hashCode_override.insert(hashCode_method).insert(definitions.ANY_HASHCODE); + environment.insertOverride(definitions.ANY_HASHCODE, hashCode_override); // !!! method java.lang.Object.notify() // !!! method java.lang.Object.notifyAll() @@ -156,30 +156,30 @@ public class Compiler { CodePromise toString_code = new CodePromise( new CodeContainer( compiled, - definitions.TOSTRING, + definitions.ANY_TOSTRING, Code.Invoke( Code.Self, Function.ToString, new Code[0], 0), 0)); - any_methods.put(definitions.TOSTRING, toString_code); + any_methods.put(definitions.ANY_TOSTRING, toString_code); any_methods.put(toString_method, toString_code); - environment.insertFunction(definitions.TOSTRING, + environment.insertFunction(definitions.ANY_TOSTRING, Function.JavaMethod(toString_method)); Override toString_override = Override.empty(); - toString_override.insert(toString_method).insert(definitions.TOSTRING); - environment.insertOverride(definitions.TOSTRING, toString_override); + toString_override.insert(toString_method).insert(definitions.ANY_TOSTRING); + environment.insertOverride(definitions.ANY_TOSTRING, toString_override); // !!! method java.lang.Object.wait() // !!! method java.lang.Object.wait(long) // !!! method java.lang.Object.wait(long, int) - environment.insertFunction(definitions.EQEQ, Function.EqEq); - Override eqeq_override = Override.empty().insert(definitions.EQEQ); - environment.insertOverride(definitions.EQEQ, eqeq_override); + environment.insertFunction(definitions.ANY_EQEQ, Function.EqEq); + Override eqeq_override = Override.empty().insert(definitions.ANY_EQEQ); + environment.insertOverride(definitions.ANY_EQEQ, eqeq_override); - environment.insertFunction(definitions.BANGEQ, Function.BangEq); - Override bangeq_override = Override.empty().insert(definitions.BANGEQ); - environment.insertOverride(definitions.BANGEQ, bangeq_override); + environment.insertFunction(definitions.ANY_BANGEQ, Function.BangEq); + Override bangeq_override = Override.empty().insert(definitions.ANY_BANGEQ); + environment.insertOverride(definitions.ANY_BANGEQ, bangeq_override); } //######################################################################## diff --git a/sources/scala/tools/scalai/ExpressionCompiler.java b/sources/scala/tools/scalai/ExpressionCompiler.java index 563ec09c1f..b88d1253ce 100644 --- a/sources/scala/tools/scalai/ExpressionCompiler.java +++ b/sources/scala/tools/scalai/ExpressionCompiler.java @@ -184,12 +184,12 @@ public class ExpressionCompiler { private Code tapply(Tree target, Symbol symbol, Tree[] trees) { Code object = object(target); - if (symbol == definitions.AS) { + if (symbol == definitions.ANY_AS) { assert trees.length == 1 : Debug.show(trees); // !!! some AS should be kept; they might fail return object; } - if (symbol == definitions.IS) { + if (symbol == definitions.ANY_IS) { assert trees.length == 1 : Debug.show(trees); //assert trees[0].hasSymbol() : trees[0]; Symbol expect = trees[0].type().symbol(); diff --git a/sources/scala/tools/scalai/Interpreter.java b/sources/scala/tools/scalai/Interpreter.java index b87114eb90..381820895e 100644 --- a/sources/scala/tools/scalai/Interpreter.java +++ b/sources/scala/tools/scalai/Interpreter.java @@ -145,7 +145,7 @@ public class Interpreter { scalac.Phase current = global.currentPhase; // !!! if (!erased) global.currentPhase = global.getFirstPhase(); Definitions definitions = global.definitions; - Type argument = definitions.arrayType(definitions.JAVA_STRING_TYPE()); + Type argument = definitions.ARRAY_TYPE(definitions.JAVA_STRING_TYPE()); Type result = definitions.UNIT_TYPE(); if (erased) argument = argument.erasure(); if (erased) result = result.fullErasure(); diff --git a/sources/scalac/ast/TreeGen.java b/sources/scalac/ast/TreeGen.java index 43e33ad80e..ebb6f29a61 100644 --- a/sources/scalac/ast/TreeGen.java +++ b/sources/scalac/ast/TreeGen.java @@ -594,7 +594,8 @@ public class TreeGen implements Kinds, Modifiers, TypeTags { /** Builds an instance test with given value and type. */ public Tree mkIsInstanceOf(int pos, Tree value, Type type) { - return mkApplyT_(pos, Select(value, definitions.IS), new Type[]{type}); + Type[] targs = new Type[]{type}; + return mkApplyT_(pos, Select(value, definitions.ANY_IS), targs); } public Tree mkIsInstanceOf(Tree value, Type type) { return mkIsInstanceOf(value.pos, value, type); @@ -602,7 +603,8 @@ public class TreeGen implements Kinds, Modifiers, TypeTags { /** Builds a cast with given value and type. */ public Tree mkAsInstanceOf(int pos, Tree value, Type type) { - return mkApplyT_(pos, Select(value, definitions.AS), new Type[]{type}); + Type[] targs = new Type[]{type}; + return mkApplyT_(pos, Select(value, definitions.ANY_AS), targs); } public Tree mkAsInstanceOf(Tree value, Type type) { return mkAsInstanceOf(value.pos, value, type); @@ -1018,7 +1020,7 @@ public class TreeGen implements Kinds, Modifiers, TypeTags { } Type[] parentTypes = { definitions.OBJECT_TYPE(), - definitions.functionType(argtypes, restype) }; + definitions.FUNCTION_TYPE(argtypes, restype) }; ClassSymbol clazz = new ClassSymbol( pos, Names.ANON_CLASS_NAME.toTypeName(), owner, 0); clazz.setInfo(Type.compoundType(parentTypes, new Scope(), clazz)); @@ -1049,7 +1051,7 @@ public class TreeGen implements Kinds, Modifiers, TypeTags { pos, Names.ANON_CLASS_NAME.toTypeName(), owner, 0); Type[] parentTypes = { definitions.OBJECT_TYPE(), - definitions.partialFunctionType(pattype, restype)}; + definitions.PARTIALFUNCTION_TYPE(pattype, restype)}; clazz.setInfo(Type.compoundType(parentTypes, new Scope(), clazz)); clazz.allConstructors().setInfo( Type.MethodType(Symbol.EMPTY_ARRAY, clazz.typeConstructor())); @@ -1077,7 +1079,7 @@ public class TreeGen implements Kinds, Modifiers, TypeTags { changeOwner(visitor, prevOwner, meth); Tree body = mkApplyTV( - Select(Ident(pos, param), definitions.MATCH), + Select(Ident(pos, param), definitions.ANY_MATCH), new Tree[]{mkType(pos, pattype), mkType(pos, restype)}, new Tree[]{visitor}); return DefDef(meth, body); diff --git a/sources/scalac/backend/Primitives.java b/sources/scalac/backend/Primitives.java index b12b97eb7d..a48be3a333 100644 --- a/sources/scalac/backend/Primitives.java +++ b/sources/scalac/backend/Primitives.java @@ -319,7 +319,7 @@ public class Primitives { } private Symbol getBoxArray(Symbol[] alts, Type type) { - return getBoxValue(alts, definitions.arrayType(type)); + return getBoxValue(alts, definitions.ARRAY_TYPE(type)); } private Symbol getUniqueTerm(Symbol owner, Name name) { @@ -339,14 +339,14 @@ public class Primitives { Definitions defs = definitions; // scala.Any - addPrimitive(defs.EQ, Primitive.ID); - addPrimitive(defs.IS, Primitive.IS); - addPrimitive(defs.AS, Primitive.AS); - addPrimitive(defs.EQEQ, Primitive.EQ); - addPrimitive(defs.BANGEQ, Primitive.NE); - // !!! addPrimitive(defs.EQUALS, Primitive.EQUALS); - addPrimitive(defs.HASHCODE, Primitive.HASHCODE); - addPrimitive(defs.TOSTRING, Primitive.TOSTRING); + addPrimitive(defs.ANY_EQ, Primitive.ID); + addPrimitive(defs.ANY_IS, Primitive.IS); + addPrimitive(defs.ANY_AS, Primitive.AS); + addPrimitive(defs.ANY_EQEQ, Primitive.EQ); + addPrimitive(defs.ANY_BANGEQ, Primitive.NE); + // !!! addPrimitive(defs.ANY_EQUALS, Primitive.EQUALS); + addPrimitive(defs.ANY_HASHCODE, Primitive.HASHCODE); + addPrimitive(defs.ANY_TOSTRING, Primitive.TOSTRING); // scala.Unit addAll(defs.UNIT_CLASS, Names.EQ, Primitive.EQ, 1); @@ -492,10 +492,10 @@ public class Primitives { addAll(defs.ARRAY_CLASS, Names.update, Primitive.UPDATE, 1); // scala.String - addPrimitive(defs.STRING_PLUS_ANY, Primitive.CONCAT); + addPrimitive(defs.JAVA_STRING_PLUS, Primitive.CONCAT); // java.lang.Throwable - addPrimitive(defs.THROW, Primitive.THROW); + addPrimitive(defs.JAVA_THROWABLE_THROW, Primitive.THROW); // scala.runtime.RunTime addPrimitive(BOX_UVALUE, Primitive.BOX); diff --git a/sources/scalac/backend/jvm/GenJVM.java b/sources/scalac/backend/jvm/GenJVM.java index 1c73938e4c..85b95efb13 100644 --- a/sources/scalac/backend/jvm/GenJVM.java +++ b/sources/scalac/backend/jvm/GenJVM.java @@ -249,10 +249,10 @@ class GenJVM { genLoadQualifier(ctx, fun, true); JType type = typeStoJ(args[0].type); - if (fun.symbol() == defs.IS) { + if (fun.symbol() == defs.ANY_IS) { ctx.code.emitINSTANCEOF((JReferenceType)type); generatedType = JType.BOOLEAN; - } else if (fun.symbol() == defs.AS) { + } else if (fun.symbol() == defs.ANY_AS) { ctx.code.emitCHECKCAST((JReferenceType)type); generatedType = type; } else diff --git a/sources/scalac/backend/msil/GenMSIL.java b/sources/scalac/backend/msil/GenMSIL.java index 82176d9a12..1de7c196f1 100644 --- a/sources/scalac/backend/msil/GenMSIL.java +++ b/sources/scalac/backend/msil/GenMSIL.java @@ -737,10 +737,10 @@ public class GenMSIL { return coerce(gen(qualifier, MSILType.VOID), MSILType.VOID); } - if (sym == defs.EQEQ) { + if (sym == defs.ANY_EQEQ) { return genEq(qualifier, args[0]); } - if (sym == defs.BANGEQ) { + if (sym == defs.ANY_BANGEQ) { return negate(genEq(qualifier, args[0])); } @@ -857,10 +857,10 @@ public class GenMSIL { /** Generate code for scala's '==' */ Item genEq(Tree left, Tree right) { - LocalBuilder tmpLocal = (LocalBuilder)locals.get(defs.EQEQ); + LocalBuilder tmpLocal = (LocalBuilder)locals.get(defs.ANY_EQEQ); if (tmpLocal == null) { tmpLocal = code.DeclareLocal(TypeCreator.SYSTEM_OBJECT); - locals.put(defs.EQEQ, tmpLocal); + locals.put(defs.ANY_EQEQ, tmpLocal); } Label l1 = code.DefineLabel(), l2 = code.DefineLabel(); load(gen(left)); diff --git a/sources/scalac/symtab/Definitions.java b/sources/scalac/symtab/Definitions.java index c7d3a3d3e8..547c998e1f 100644 --- a/sources/scalac/symtab/Definitions.java +++ b/sources/scalac/symtab/Definitions.java @@ -9,111 +9,202 @@ package scalac.symtab; import ch.epfl.lamp.util.Position; -import scalac.*; -import scalac.util.*; -import scalac.symtab.classfile.*; -import Type.*; + +import scalac.Global; +import scalac.symtab.classfile.PackageParser; +import scalac.util.Debug; +import scalac.util.Name; +import scalac.util.Names; public class Definitions { - /** the root module - */ + //######################################################################## + // Public Fields & Methods - Root module + + /** The root module */ public final Symbol ROOT; public final Symbol ROOT_CLASS; + public final Type ROOT_TYPE() {return ROOT_CLASS.type();} - /** the null value - */ - public final Symbol NULL; - - /** the zero value (a default null for type variables with bound Any) - */ - public final Symbol ZERO; + //######################################################################## + // Public Fields & Methods - Top and bottom classes - /** the scala.Any class - */ + /** The scala.Any class */ public final Symbol ANY_CLASS; public final Type ANY_TYPE() {return ANY_CLASS.type();} - public final Symbol MATCH; - public final Symbol IS; - public final Symbol AS; - public final Symbol EQEQ; - public final Symbol BANGEQ; - public final Symbol EQUALS; - public final Symbol EQ; - public final Symbol TOSTRING; - public final Symbol HASHCODE; - - /** the scala.AnyVal class - */ + /** The scala.AnyVal class */ public final Symbol ANYVAL_CLASS; public final Type ANYVAL_TYPE() {return ANYVAL_CLASS.type();} - /** the scala.AnyRef class - */ + /** The scala.AnyRef class */ public final Symbol ANYREF_CLASS; public final Type ANYREF_TYPE() {return ANYREF_CLASS.type();} - /** the scala.AllRef class - */ + /** The scala.AllRef class */ public final Symbol ALLREF_CLASS; public final Type ALLREF_TYPE() {return ALLREF_CLASS.type();} - /** the scala.All class - */ + /** The scala.All class */ public final Symbol ALL_CLASS; public final Type ALL_TYPE() {return ALL_CLASS.type();} - /** the java.lang.Object class - */ + //######################################################################## + // Public Fields & Methods - Java classes + + /** The java.lang.Object class */ public final Symbol JAVA_OBJECT_CLASS; public final Type JAVA_OBJECT_TYPE() {return JAVA_OBJECT_CLASS.type();} - /** the java.lang.String class - */ + /** The java.lang.String class */ public final Symbol JAVA_STRING_CLASS; public final Type JAVA_STRING_TYPE() {return JAVA_STRING_CLASS.type();} - /** the java.lang.Throwable class - */ + /** The java.lang.Throwable class */ public final Symbol JAVA_THROWABLE_CLASS; public final Type JAVA_THROWABLE_TYPE() {return JAVA_THROWABLE_CLASS.type();} - public final Symbol THROW; + //######################################################################## + // Public Fields & Methods - Scala value classes - /** the scala.Object class - */ - public final Symbol OBJECT_CLASS; - public final Type OBJECT_TYPE() {return OBJECT_CLASS.type();} + /** The scala.Unit class */ + public final Symbol UNIT_CLASS; + public final Type UNIT_TYPE() {return UNIT_CLASS.type();} - private Symbol OBJECT_TAG; - public Symbol OBJECT_TAG() { - if (OBJECT_TAG == null) - OBJECT_TAG = loadTerm(OBJECT_CLASS, Names.tag); - return OBJECT_TAG; - } + /** The scala.Boolean class */ + public final Symbol BOOLEAN_CLASS; + public final Type BOOLEAN_TYPE() {return BOOLEAN_CLASS.type();} - /** the primitive types - */ + /** The scala.Byte class */ public final Symbol BYTE_CLASS; public final Type BYTE_TYPE() {return BYTE_CLASS.type();} + + /** The scala.Short class */ public final Symbol SHORT_CLASS; public final Type SHORT_TYPE() {return SHORT_CLASS.type();} + + /** The scala.Char class */ public final Symbol CHAR_CLASS; public final Type CHAR_TYPE() {return CHAR_CLASS.type();} + + /** The scala.Int class */ public final Symbol INT_CLASS; public final Type INT_TYPE() {return INT_CLASS.type();} + + /** The scala.Long class */ public final Symbol LONG_CLASS; public final Type LONG_TYPE() {return LONG_CLASS.type();} + + /** The scala.Float class */ public final Symbol FLOAT_CLASS; public final Type FLOAT_TYPE() {return FLOAT_CLASS.type();} + + /** The scala.Double class */ public final Symbol DOUBLE_CLASS; public final Type DOUBLE_TYPE() {return DOUBLE_CLASS.type();} - public final Symbol BOOLEAN_CLASS; - public final Type BOOLEAN_TYPE() {return BOOLEAN_CLASS.type();} - public final Symbol UNIT_CLASS; - public final Type UNIT_TYPE() {return UNIT_CLASS.type();} + //######################################################################## + // Public Fields & Methods - Scala reference classes + + /** The scala.Object class */ + public final Symbol OBJECT_CLASS; + public final Type OBJECT_TYPE() {return OBJECT_CLASS.type();} + + /** The scala.String class */ + public final Symbol STRING_CLASS; + public final Type STRING_TYPE() {return STRING_CLASS.type();} + + /** The scala.Ref class */ + public final Symbol REF_CLASS; + public final Type REF_TYPE(Type element) { + return getType(REF_CLASS, element); + } + + /** The scala.TupleX classes */ + public final int TUPLE_COUNT = 10; + public final Symbol[] TUPLE_CLASS = new Symbol[TUPLE_COUNT]; + public final Type TUPLE_TYPE(Type[] args) { + assert 0 < args.length && args.length < TUPLE_COUNT: args.length; + return getType(TUPLE_CLASS[args.length], args); + } + + /** The scala.FunctionX classes */ + public final int FUNCTION_COUNT = 10; + public final Symbol[] FUNCTION_CLASS = new Symbol[FUNCTION_COUNT]; + public final Type FUNCTION_TYPE(Type[] args, Type result) { + assert 0 <= args.length && args.length < FUNCTION_COUNT: args.length; + args = Type.cloneArray(args, 1); + args[args.length - 1] = result; + return getType(FUNCTION_CLASS[args.length - 1], args); + } + + /** The scala.PartialFunction class */ + public final Symbol PARTIALFUNCTION_CLASS; + public final Type PARTIALFUNCTION_TYPE(Type argument, Type result) { + return getType(PARTIALFUNCTION_CLASS, new Type[] { argument, result }); + } + + /** The scala.Iterable class */ + public final Symbol ITERABLE_CLASS; + public final Type ITERABLE_TYPE(Type element) { + return getType(ITERABLE_CLASS, element); + } + + /** The scala.Iterator class */ + public final Symbol ITERATOR_CLASS; + public final Type ITERATOR_TYPE(Type element) { + return getType(ITERATOR_CLASS, element); + } + + /** The scala.Seq class */ + public final Symbol SEQ_CLASS; + public final Type SEQ_TYPE(Type element) { + return getType(SEQ_CLASS, element); + } + + /** The scala.List class */ + public final Symbol LIST_CLASS; + public final Type LIST_TYPE(Type element) { + return getType(LIST_CLASS, element); + } + + /** The scala.Array class */ + public final Symbol ARRAY_CLASS; + public final Type ARRAY_TYPE(Type element) { + return getType(ARRAY_CLASS, element); + } + + /** The scala.MatchError module */ + public final Symbol MATCHERROR; + + //######################################################################## + // Public Fields & Methods - Top and bottom class methods + + /** Some scala.Any methods */ + public final Symbol ANY_EQ; + public final Symbol ANY_EQEQ; + public final Symbol ANY_BANGEQ; + public final Symbol ANY_EQUALS; + public final Symbol ANY_HASHCODE; + public final Symbol ANY_TOSTRING; + //public final Symbol ANY_PLUS; + public final Symbol ANY_IS; + public final Symbol ANY_AS; + public final Symbol ANY_MATCH; + + //######################################################################## + // Public Fields & Methods - Java class methods + + /** Some java.lang.String methods */ + public final Symbol JAVA_STRING_PLUS; + + /** Some java.lang.Throwable methods */ + public final Symbol JAVA_THROWABLE_THROW; + + //######################################################################## + // Public Fields & Methods - Scala value class methods + + /** Some scala.Boolean methods */ private Symbol BOOLEAN_OR; private Symbol BOOLEAN_AND; private Symbol BOOLEAN_NOT; @@ -134,60 +225,49 @@ public class Definitions { return BOOLEAN_NOT; } - /** the scala.String class - */ - public final Symbol STRING_CLASS; - public final Type STRING_TYPE() {return STRING_CLASS.type();} + //######################################################################## + // Public Fields & Methods - Scala reference class methods - /** the scala.TupleX classes - */ - public final int TUPLE_count = 10; - public final Symbol[] TUPLE_CLASS = new Symbol[TUPLE_count]; + /** Some scala.Object methods */ + private Symbol OBJECT_TAG; - public Type tupleType(Type[] args) { - assert 0 < args.length && args.length < TUPLE_count: args.length; - return getType(TUPLE_CLASS[args.length], args); + public Symbol OBJECT_TAG() { + if (OBJECT_TAG == null) + OBJECT_TAG = loadTerm(OBJECT_CLASS, Names.tag); + return OBJECT_TAG; + } + + /** Some scala.Ref methods */ + private Symbol REF_ELEM; + + public Symbol REF_ELEM() { + if (REF_ELEM == null) + REF_ELEM = loadTerm(REF_CLASS, Names.elem); + return REF_ELEM; } - private final Symbol[][] TUPLE_FIELD = new Symbol[TUPLE_count][]; + /** Some scala.TupleX methods */ + private final Symbol[][] TUPLE_FIELD = new Symbol[TUPLE_COUNT][]; public Symbol TUPLE_FIELD(int arity, int index) { - assert 0 < arity && arity < TUPLE_count: arity; + assert 0 < arity && arity < TUPLE_COUNT: arity; assert 0 < index && index <= arity: arity + " - " + index; if (TUPLE_FIELD[arity][index - 1] == null) TUPLE_FIELD[arity][index - 1] = loadTerm(TUPLE_CLASS[arity],Names.TUPLE_FIELD(index)); return TUPLE_FIELD[arity][index - 1]; } - /** the scala.FunctionX classes - */ - public final int FUNCTION_count = 10; - public final Symbol[] FUNCTION_CLASS = new Symbol[FUNCTION_count]; - - public Type functionType(Type[] args, Type result) { - assert 0 <= args.length && args.length < FUNCTION_count: args.length; - args = Type.cloneArray(args, 1); - args[args.length - 1] = result; - return getType(FUNCTION_CLASS[args.length - 1], args); - } - - private final Symbol[] FUNCTION_APPLY = new Symbol[FUNCTION_count]; + /** Some scala.FunctionX methods */ + private final Symbol[] FUNCTION_APPLY = new Symbol[FUNCTION_COUNT]; public Symbol FUNCTION_APPLY(int arity) { - assert 0 <= arity && arity < FUNCTION_count: arity; + assert 0 <= arity && arity < FUNCTION_COUNT: arity; if (FUNCTION_APPLY[arity] == null) FUNCTION_APPLY[arity] = loadTerm(FUNCTION_CLASS[arity],Names.apply); return FUNCTION_APPLY[arity]; } - /** the scala.PartialFunction class - */ - public final Symbol PARTIALFUNCTION_CLASS; - - public Type partialFunctionType(Type arg, Type result) { - return getType(PARTIALFUNCTION_CLASS, new Type[] { arg, result }); - } - + /** Some scala.PartialFunction methods */ private Symbol PARTIALFUNCTION_ISDEFINEDAT; public Symbol PARTIALFUNCTION_ISDEFINEDAT() { @@ -196,32 +276,40 @@ public class Definitions { return PARTIALFUNCTION_ISDEFINEDAT; } - /** the scala.Ref class - */ - public final Symbol REF_CLASS; + /** Some scala.Iterable methods */ + private Symbol ITERABLE_ELEMENTS; - public Type refType(Type element) { - return getType(REF_CLASS, element); + public Symbol ITERABLE_ELEMENTS() { + if (ITERABLE_ELEMENTS == null) + ITERABLE_ELEMENTS = loadTerm(ITERABLE_CLASS, Names.elements); + return ITERABLE_ELEMENTS; } - private Symbol REF_ELEM; + /** Some scala.Iterator methods */ + private Symbol ITERATOR_NEXT; + private Symbol ITERATOR_HASNEXT; - public Symbol REF_ELEM() { - if (REF_ELEM == null) - REF_ELEM = loadTerm(REF_CLASS, Names.elem); - return REF_ELEM; + public Symbol ITERATOR_NEXT() { + if (ITERATOR_NEXT == null) + ITERATOR_NEXT = loadTerm(ITERATOR_CLASS, Names.next); + return ITERATOR_NEXT; + } + public Symbol ITERATOR_HASNEXT() { + if (ITERATOR_HASNEXT == null) + ITERATOR_HASNEXT = loadTerm(ITERATOR_CLASS, Names.hasNext); + return ITERATOR_HASNEXT; } - /** the scala.List class - */ - public final Symbol LIST_CLASS; - // !!! public final Symbol LIST_NIL_CLASS; - // !!! public final Symbol LIST_CONS_CLASS; + /** Some scala.Seq methods */ + private Symbol SEQ_LENGTH; - public Type listType(Type element) { - return getType(LIST_CLASS, element); + public Symbol SEQ_LENGTH() { + if (SEQ_LENGTH == null) + SEQ_LENGTH = loadTerm(SEQ_CLASS, Names.length); + return SEQ_LENGTH; } + /** Some scala.List methods */ private Symbol LIST_ISEMPTY; private Symbol LIST_HEAD; private Symbol LIST_TAIL; @@ -242,73 +330,7 @@ public class Definitions { return LIST_TAIL; } - /** the scala.Iterator class - */ - public final Symbol ITERATOR_CLASS; - - public Type iteratorType(Type element) { - return getType(ITERATOR_CLASS, element); - } - - private Symbol ITERATOR_NEXT; - private Symbol ITERATOR_HASNEXT; - - public Symbol ITERATOR_NEXT() { - if (ITERATOR_NEXT == null) - ITERATOR_NEXT = loadTerm(ITERATOR_CLASS, Names.next); - return ITERATOR_NEXT; - } - public Symbol ITERATOR_HASNEXT() { - if (ITERATOR_HASNEXT == null) - ITERATOR_HASNEXT = loadTerm(ITERATOR_CLASS, Names.hasNext); - return ITERATOR_HASNEXT; - } - - /** the scala.Iterable class - */ - public final Symbol ITERABLE_CLASS; - - public Type iterableType(Type element) { - return getType(ITERABLE_CLASS, element); - } - - private Symbol ITERABLE_ELEMENTS; - - public Symbol ITERABLE_ELEMENTS() { - if (ITERABLE_ELEMENTS == null) - ITERABLE_ELEMENTS = loadTerm(ITERABLE_CLASS, Names.elements); - return ITERABLE_ELEMENTS; - } - - /** the scala.Seq class - */ - public final Symbol SEQ_CLASS; - - public Type seqType(Type element) { - return getType(SEQ_CLASS, element); - } - - private Symbol SEQ_LENGTH; - - public Symbol SEQ_LENGTH() { - if (SEQ_LENGTH == null) - SEQ_LENGTH = loadTerm(SEQ_CLASS, Names.length); - return SEQ_LENGTH; - } - - /** the scala.Array class - */ - public final Symbol ARRAY_CLASS; - - public Type arrayType(Type element) { - return getType(ARRAY_CLASS, element); - } - - /** the scala.MatchError class - */ - public final Symbol MATCHERROR; - public final Symbol MATCHERROR_CLASS; - + /** Some scala.MatchError methods */ private Symbol MATCHERROR_FAIL; public Symbol MATCHERROR_FAIL() { @@ -317,222 +339,146 @@ public class Definitions { return MATCHERROR_FAIL; } - /** string concatenation pseudo-methods of classes scala.Any and - * java.lang.String - */ - //public final Symbol ANY_PLUS_STRING; - public final Symbol STRING_PLUS_ANY; + //######################################################################## + // Public Fields - Global values + + /** The null value */ + public final Symbol NULL; + + /** The zero value (a default null for type variables with bound Any) */ + public final Symbol ZERO; + /** The universal pattern */ public final Symbol PATTERN_WILDCARD; + //######################################################################## + // Public Constructor + + /** Initializes this instance. */ public Definitions(Global global) { - // a hack to make definitions accessible earlier to other - // components + // make definitions accessible earlier to other components global.definitions = this; - PackageParser pparser = new PackageParser(global); + // force initialization of class Type + Type.localThisType.symbol(); - // this is the root value; all top-level functions, - // modules etc. are a member of this value + // the root module ROOT = TermSymbol.newJavaPackageModule( - Names.ROOT, Symbol.NONE, pparser); + Names.ROOT, Symbol.NONE, new PackageParser(global)); ROOT_CLASS = ROOT.moduleClass(); - // the scala class - Symbol SCALA_CLASS = getClass(Names.scala); + // the scala package + Symbol SCALA_PACKAGE = getClass(Names.scala); - // the scala.ANY classs - ANY_CLASS = new ClassSymbol( - Position.NOPOS, Names.Any.toTypeName(), SCALA_CLASS, Modifiers.JAVA); - SCALA_CLASS.members().enter(ANY_CLASS); - ANY_CLASS.setInfo(Type.compoundType(Type.EMPTY_ARRAY, new Scope(), ANY_CLASS)); - ANY_CLASS.primaryConstructor().setInfo( - Type.MethodType(Symbol.EMPTY_ARRAY, ANY_CLASS.typeConstructor())); + // the top and bottom classes + ANY_CLASS = newClass(SCALA_PACKAGE, Names.Any, Modifiers.JAVA); + ANYVAL_CLASS = getClass(Names.scala_AnyVal); + ANYREF_CLASS = newAlias(SCALA_PACKAGE, Names.AnyRef, Modifiers.JAVA); + ALLREF_CLASS = newClass(SCALA_PACKAGE, Names.AllRef, 0); + ALL_CLASS = newClass(SCALA_PACKAGE, Names.All, 0); - // the java.lang.OBJECT class + // the java classes JAVA_OBJECT_CLASS = getClass(Names.java_lang_Object); + JAVA_THROWABLE_CLASS = getClass(Names.java_lang_Throwable); + JAVA_STRING_CLASS = getClass(Names.java_lang_String); - // the primitive types - DOUBLE_CLASS = getClass(Names.scala_Double); - FLOAT_CLASS = getClass(Names.scala_Float); - LONG_CLASS = getClass(Names.scala_Long); - INT_CLASS = getClass(Names.scala_Int); - CHAR_CLASS = getClass(Names.scala_Char); - SHORT_CLASS = getClass(Names.scala_Short); - BYTE_CLASS = getClass(Names.scala_Byte); - BOOLEAN_CLASS = getClass(Names.scala_Boolean); + // the scala value classes UNIT_CLASS = getClass(Names.scala_Unit); + BOOLEAN_CLASS = getClass(Names.scala_Boolean); + BYTE_CLASS = getClass(Names.scala_Byte); + SHORT_CLASS = getClass(Names.scala_Short); + CHAR_CLASS = getClass(Names.scala_Char); + INT_CLASS = getClass(Names.scala_Int); + LONG_CLASS = getClass(Names.scala_Long); + FLOAT_CLASS = getClass(Names.scala_Float); + DOUBLE_CLASS = getClass(Names.scala_Double); - // the scala.ANYREF class - ANYREF_CLASS = new AliasTypeSymbol( - Position.NOPOS, Names.AnyRef.toTypeName(), - SCALA_CLASS, Modifiers.JAVA) - .setInfo(JAVA_OBJECT_TYPE()); - SCALA_CLASS.members().enter(ANYREF_CLASS); - ANYREF_CLASS.primaryConstructor().setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, JAVA_OBJECT_TYPE())); - - // the scala.OBJECT class + // the scala reference classes OBJECT_CLASS = getClass(Names.scala_Object); - - // the scala.ANYVAL class - ANYVAL_CLASS = getClass(Names.scala_AnyVal); - - // the scala.ALL class - ALL_CLASS = new ClassSymbol( - Position.NOPOS, Names.All.toTypeName(), SCALA_CLASS, 0); - SCALA_CLASS.members().enter(ALL_CLASS); - ALL_CLASS.setInfo(Type.compoundType(new Type[]{ANY_TYPE()}, new Scope(), ALL_CLASS)); - ALL_CLASS.primaryConstructor().setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, ALL_CLASS.typeConstructor())); - - // the scala.ALLREF class - ALLREF_CLASS = new ClassSymbol( - Position.NOPOS, Names.AllRef.toTypeName(), SCALA_CLASS, 0); - SCALA_CLASS.members().enter(ALLREF_CLASS); - ALLREF_CLASS.setInfo(Type.compoundType(new Type[]{ANYREF_TYPE()}, new Scope(), ALLREF_CLASS)); - ALLREF_CLASS.primaryConstructor().setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, ALLREF_CLASS.typeConstructor())); - - // the array class - ARRAY_CLASS = getClass(Names.scala_Array); - - // add members to java.lang.Throwable - JAVA_THROWABLE_CLASS = getClass(Names.java_lang_Throwable); - THROW = new TermSymbol( - Position.NOPOS, Names.throw_, JAVA_THROWABLE_CLASS, Modifiers.FINAL); - THROW.setInfo(Type.PolyType(Symbol.EMPTY_ARRAY, ALL_TYPE())); - JAVA_THROWABLE_CLASS.members().enter(THROW); - - // add the java.lang.String class to the scala package - JAVA_STRING_CLASS = getClass(Names.java_lang_String); - STRING_CLASS = new AliasTypeSymbol( - Position.NOPOS, Names.String.toTypeName(), SCALA_CLASS, 0) - .setInfo(JAVA_STRING_TYPE()); - SCALA_CLASS.members().enter(STRING_CLASS); - STRING_CLASS.primaryConstructor().setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, STRING_CLASS.typeConstructor())); - - for (int i = 1; i < TUPLE_count; i++) { + STRING_CLASS = newAlias(SCALA_PACKAGE, Names.String, 0); + REF_CLASS = getClass(Names.scala_Ref); + for (int i = 1; i < TUPLE_COUNT; i++) { TUPLE_CLASS[i] = getClass(Names.scala_Tuple(i)); TUPLE_FIELD[i] = new Symbol[i]; } - for (int i = 0; i < FUNCTION_count; i++) + for (int i = 0; i < FUNCTION_COUNT; i++) FUNCTION_CLASS[i] = getClass(Names.scala_Function(i)); PARTIALFUNCTION_CLASS = getClass(Names.scala_PartialFunction); - REF_CLASS = getClass(Names.scala_Ref); - LIST_CLASS = getClass(Names.scala_List); - ITERATOR_CLASS = getClass(Names.scala_Iterator); ITERABLE_CLASS = getClass(Names.scala_Iterable); + ITERATOR_CLASS = getClass(Names.scala_Iterator); SEQ_CLASS = getClass(Names.scala_Seq); + LIST_CLASS = getClass(Names.scala_List); + ARRAY_CLASS = getClass(Names.scala_Array); MATCHERROR = getModule(Names.scala_MatchError); - MATCHERROR_CLASS = getClass(Names.scala_MatchError); - - /* - ANY_PLUS_STRING = new TermSymbol( - Position.NOPOS, Names.PLUS, ANY_CLASS, Modifiers.FINAL); - ANY_PLUS_STRING.setInfo( - Type.MethodType( - new Symbol[]{newParameter(ANY_PLUS_STRING, STRING_TYPE)}, - STRING_TYPE)); - ANY_CLASS.members().enter(ANY_PLUS_STRING); - */ - - STRING_PLUS_ANY = new TermSymbol( - Position.NOPOS, Names.PLUS, JAVA_STRING_CLASS, Modifiers.FINAL); - STRING_PLUS_ANY.setInfo( - Type.MethodType( - new Symbol[]{newParameter(STRING_PLUS_ANY, ANY_TYPE())}, - STRING_TYPE())); - JAVA_STRING_CLASS.members().enter(STRING_PLUS_ANY); - - // add members to class scala.Any - MATCH = new TermSymbol( - Position.NOPOS, Names.match, ANY_CLASS, Modifiers.FINAL); - Symbol matchTyParam1 = newTypeParameter(MATCH, ANY_TYPE()); - Symbol matchTyParam2 = newTypeParameter(MATCH, ANY_TYPE()); - MATCH.setInfo( + + // initialize generated classes and aliases + initClass(ANY_CLASS, Type.EMPTY_ARRAY); + initAlias(ANYREF_CLASS, JAVA_OBJECT_TYPE()); + initClass(ALLREF_CLASS, new Type[]{ANYREF_TYPE()}); + initClass(ALL_CLASS, new Type[]{ANY_TYPE()}); + initAlias(STRING_CLASS, JAVA_STRING_TYPE()); + + // add members to scala.Any + ANY_EQ = newTerm(ANY_CLASS, Names.eq , 0); + ANY_EQEQ = newTerm(ANY_CLASS, Names.EQEQ , Modifiers.FINAL); + ANY_BANGEQ = newTerm(ANY_CLASS, Names.BANGEQ , Modifiers.FINAL); + ANY_EQUALS = newTerm(ANY_CLASS, Names.equals , 0); + ANY_HASHCODE = newTerm(ANY_CLASS, Names.hashCode , 0); + ANY_TOSTRING = newTerm(ANY_CLASS, Names.toString , 0); + // ANY_PLUS = newTerm(ANY_CLASS, Names.PLUS , Modifiers.FINAL); + ANY_IS = newTerm(ANY_CLASS, Names.isInstanceOf, Modifiers.FINAL); + ANY_AS = newTerm(ANY_CLASS, Names.asInstanceOf, Modifiers.FINAL); + ANY_MATCH = newTerm(ANY_CLASS, Names.match , Modifiers.FINAL); + + initMethod(ANY_EQ , new Type[]{ANY_TYPE()} , BOOLEAN_TYPE()); + initMethod(ANY_EQEQ , new Type[]{ANY_TYPE()} , BOOLEAN_TYPE()); + initMethod(ANY_BANGEQ , new Type[]{ANY_TYPE()} , BOOLEAN_TYPE()); + initMethod(ANY_EQUALS , new Type[]{ANY_TYPE()} , BOOLEAN_TYPE()); + initMethod(ANY_HASHCODE, new Type[]{} , INT_TYPE()); + initMethod(ANY_TOSTRING, new Type[]{} , STRING_TYPE()); + // initMethod(ANY_PLUS , new Type[]{STRING_TYPE()}, STRING_TYPE()); + + Symbol[] ANY_IS_TPARAMS = {newTParam(ANY_IS, 0, ANY_TYPE())}; + ANY_IS.setInfo(Type.PolyType(ANY_IS_TPARAMS, BOOLEAN_TYPE())); + + Symbol[] ANY_AS_TPARAMS = {newTParam(ANY_AS, 0, ANY_TYPE())}; + ANY_AS.setInfo(Type.PolyType(ANY_AS_TPARAMS,ANY_AS_TPARAMS[0].type())); + + Symbol[] ANY_MATCH_TPARAMS = { + newTParam(ANY_MATCH, 0, ANY_TYPE()), + newTParam(ANY_MATCH, 1, ANY_TYPE())}; + Symbol[] ANY_MATCH_VPARAMS = { + newVParam(ANY_MATCH, 0, FUNCTION_TYPE( + new Type[]{ANY_MATCH_TPARAMS[0].type()}, + ANY_MATCH_TPARAMS[1].type()))}; + ANY_MATCH.setInfo( Type.PolyType( - new Symbol[]{matchTyParam1, matchTyParam2}, + ANY_MATCH_TPARAMS, Type.MethodType( - new Symbol[]{ - newParameter( - MATCH, - functionType( - new Type[]{matchTyParam1.typeConstructor()}, - matchTyParam2.typeConstructor()))}, - matchTyParam2.typeConstructor()))); - ANY_CLASS.members().enter(MATCH); - - AS = new TermSymbol( - Position.NOPOS, Names.asInstanceOf, ANY_CLASS, Modifiers.FINAL); - Symbol tvar = newTypeParameter(AS, ANY_TYPE()); - AS.setInfo(Type.PolyType(new Symbol[]{tvar}, tvar.type())); - ANY_CLASS.members().enter(AS); - - IS = new TermSymbol( - Position.NOPOS, Names.isInstanceOf, ANY_CLASS, Modifiers.FINAL); - IS.setInfo(Type.PolyType(new Symbol[]{newTypeParameter(IS, ANY_TYPE())}, - BOOLEAN_TYPE())); - ANY_CLASS.members().enter(IS); - - EQEQ = new TermSymbol( - Position.NOPOS, Names.EQEQ, ANY_CLASS, Modifiers.FINAL); - EQEQ.setInfo(Type.MethodType(new Symbol[]{newParameter(EQEQ, ANY_TYPE())}, - BOOLEAN_TYPE())); - ANY_CLASS.members().enter(EQEQ); - - BANGEQ = new TermSymbol( - Position.NOPOS, Names.BANGEQ, ANY_CLASS, Modifiers.FINAL); - BANGEQ.setInfo(Type.MethodType(new Symbol[]{newParameter(BANGEQ, ANY_TYPE())}, - BOOLEAN_TYPE())); - ANY_CLASS.members().enter(BANGEQ); - - EQUALS = new TermSymbol( - Position.NOPOS, Names.equals, ANY_CLASS, 0); - EQUALS.setInfo(Type.MethodType(new Symbol[]{newParameter(EQUALS, ANY_TYPE())}, - BOOLEAN_TYPE())); - ANY_CLASS.members().enter(EQUALS); - - EQ = new TermSymbol( - Position.NOPOS, Names.eq, ANY_CLASS, 0); - EQ.setInfo(Type.MethodType(new Symbol[]{newParameter(EQ, ANY_TYPE())}, - BOOLEAN_TYPE())); - ANY_CLASS.members().enter(EQ); - - TOSTRING = new TermSymbol( - Position.NOPOS, Names.toString, ANY_CLASS, 0); - TOSTRING.setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, STRING_TYPE())); - ANY_CLASS.members().enter(TOSTRING); - - HASHCODE = new TermSymbol( - Position.NOPOS, Names.hashCode, ANY_CLASS, 0); - HASHCODE.setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, INT_TYPE())); - ANY_CLASS.members().enter(HASHCODE); - - // add a null value to the root scope - NULL = new TermSymbol( - Position.NOPOS, Names.null_, ROOT_CLASS, 0); - NULL.setInfo(ALLREF_TYPE()); - ROOT.members().enter(NULL); - - // add a null value to the root scope - ZERO = new TermSymbol( - Position.NOPOS, Names.ZERO, ROOT_CLASS, 0); - ZERO.setInfo(ALL_TYPE()); - ROOT.members().enter(ZERO); - - PATTERN_WILDCARD = new TermSymbol( - Position.NOPOS, Names.PATTERN_WILDCARD, Symbol.NONE, 0); - PATTERN_WILDCARD.setType(ALL_TYPE()); - } - - private Symbol newParameter(Symbol owner, Type tp) { - return new TermSymbol(Position.NOPOS, Name.fromString("v"), owner, Modifiers.PARAM) - .setInfo(tp); - } - - private Symbol newTypeParameter(Symbol owner, Type bound) { - return new AbsTypeSymbol( - Position.NOPOS, Name.fromString("T").toTypeName(), owner, Modifiers.PARAM) - .setInfo(bound); + ANY_MATCH_VPARAMS, + ANY_MATCH_TPARAMS[1].type()))); + + // add members to java.lang.String + JAVA_STRING_PLUS = + newTerm(JAVA_STRING_CLASS, Names.PLUS, Modifiers.FINAL); + initMethod(JAVA_STRING_PLUS, new Type[]{ANY_TYPE()}, STRING_TYPE()); + + // add members to java.lang.Throwable + JAVA_THROWABLE_THROW = + newTerm(JAVA_THROWABLE_CLASS, Names.throw_, Modifiers.FINAL); + JAVA_THROWABLE_THROW.setInfo( + Type.PolyType(Symbol.EMPTY_ARRAY, ALL_TYPE())); + + // create global values + NULL = newTerm(ROOT_CLASS, Names.null_, 0).setInfo(ALLREF_TYPE()); + ZERO = newTerm(ROOT_CLASS, Names.ZERO, 0).setInfo(ALL_TYPE()); + PATTERN_WILDCARD = newTerm(Symbol.NONE, Names.PATTERN_WILDCARD, 0) + .setType(ALL_TYPE()); } + //######################################################################## + // Public Methods + + /** Returns the symbol of the module with the given fullname. */ public Symbol getModule(Name fullname) { Scope scope = ROOT_CLASS.members(); int i = 0; @@ -554,6 +500,7 @@ public class Definitions { return sym; } + /** Returns the symbol of the class with the given fullname. */ public Symbol getClass(Name fullname) { Scope scope = ROOT_CLASS.members(); int i = 0; @@ -568,20 +515,89 @@ public class Definitions { return sym; } + /** Returns the type of the class with the given fullname. */ public Type getType(Name fullname) { return getClass(fullname).type(); } + //######################################################################## + // Private Methods + + /** Creates a new class */ + private Symbol newClass(Symbol owner, Name name, int flags) { + name = name.toTypeName(); + Symbol clasz = new ClassSymbol(Position.NOPOS, name, owner, flags); + owner.members().enter(clasz); + return clasz; + } + + /** Creates a new type alias */ + private Symbol newAlias(Symbol owner, Name name, int flags) { + name = name.toTypeName(); + Symbol alias = new AliasTypeSymbol(Position.NOPOS, name, owner, flags); + owner.members().enter(alias); + return alias; + } + + /** Creates a new term */ + private Symbol newTerm(Symbol owner, Name name, int flags) { + Symbol method = new TermSymbol(Position.NOPOS, name, owner, flags); + if (owner != Symbol.NONE) owner.members().enterOrOverload(method); + return method; + } + + /** Creates a new type parameter */ + private Symbol newTParam(Symbol owner, int index, Type bound) { + Name name = Name.fromString("T" + index).toTypeName(); + return new AbsTypeSymbol(Position.NOPOS, name, owner, Modifiers.PARAM) + .setInfo(bound); + } + + /** Creates a new value parameter */ + private Symbol newVParam(Symbol owner, int index, Type type) { + Name name = Name.fromString("v" + index); + return new TermSymbol(Position.NOPOS, name, owner, Modifiers.PARAM) + .setInfo(type); + } + + /** Initializes the given class */ + private void initClass(Symbol clasz, Type[] parents) { + clasz.setInfo(Type.compoundType(parents, new Scope(), clasz)); + clasz.primaryConstructor().setInfo( + Type.MethodType(Symbol.EMPTY_ARRAY, clasz.typeConstructor())); + } + + /** Initializes the given type alias */ + private void initAlias(Symbol alias, Type aliased) { + alias.setInfo(aliased); + alias.primaryConstructor().setInfo( + Type.MethodType(Symbol.EMPTY_ARRAY, aliased)); + } + + /** Initializes the given method */ + private void initMethod(Symbol method, Type[] vargs, Type result) { + Symbol[] vparams = new Symbol[vargs.length]; + for (int i = 0; i < vargs.length; i++) + vparams[i] = newVParam(method, i, vargs[i]); + method.setInfo(Type.MethodType(vparams, result)); + } + + /** Returns the term member of given class with given name. */ private Symbol loadTerm(Symbol clasz, Name name) { Symbol sym = clasz.lookup(name); assert sym.isTerm() && !sym.isOverloaded(): clasz+"."+name+" -> "+sym; return sym; } + /** Returns the type of given class applied to given type argument. */ private Type getType(Symbol clasz, Type arg) { return getType(clasz, new Type[] { arg }); } + + /** Returns the type of given class applied to given type arguments. */ private Type getType(Symbol clasz, Type[] args) { return Type.appliedType(clasz.typeConstructor(), args); } + + //######################################################################## } diff --git a/sources/scalac/symtab/classfile/JavaTypeCreator.java b/sources/scalac/symtab/classfile/JavaTypeCreator.java index 7126d182cd..0e5653f9e1 100644 --- a/sources/scalac/symtab/classfile/JavaTypeCreator.java +++ b/sources/scalac/symtab/classfile/JavaTypeCreator.java @@ -90,7 +90,7 @@ public class JavaTypeCreator implements JavaTypeFactory { } public Type arrayType(Type elemtpe) { - return definitions.arrayType(elemtpe); + return definitions.ARRAY_TYPE(elemtpe); } public Type methodType(Type[] argtpes, Type restpe, Type[] thrown) { diff --git a/sources/scalac/transformer/Erasure.java b/sources/scalac/transformer/Erasure.java index 79cfbaacc2..0b5b3b29d8 100644 --- a/sources/scalac/transformer/Erasure.java +++ b/sources/scalac/transformer/Erasure.java @@ -172,11 +172,11 @@ public class Erasure extends Transformer implements Modifiers { fun = transform(fun); vargs = transform(vargs); Symbol symbol = fun.symbol(); - if (symbol == definitions.AS) { + if (symbol == definitions.ANY_AS) { assert targs.length == 1 && vargs.length == 0: tree; return coerce(getQualifier(fun), targs[0].type().erasure()); } - if (symbol == definitions.IS) { + if (symbol == definitions.ANY_IS) { assert targs.length == 1 && vargs.length == 0: tree; Type type = targs[0].type.erasure(); if (isUnboxedSimpleType(type)) type = targs[0].type; diff --git a/sources/scalac/transformer/LambdaLiftPhase.java b/sources/scalac/transformer/LambdaLiftPhase.java index e9b19a3e6e..6919c56364 100644 --- a/sources/scalac/transformer/LambdaLiftPhase.java +++ b/sources/scalac/transformer/LambdaLiftPhase.java @@ -48,7 +48,7 @@ public class LambdaLiftPhase extends Phase implements Kinds, Modifiers { } } if ((sym.flags & Modifiers.CAPTURED) != 0) - return global.definitions.refType(tp1); + return global.definitions.REF_TYPE(tp1); else return tp1; } diff --git a/sources/scalac/transformer/UnCurry.java b/sources/scalac/transformer/UnCurry.java index 488c21e731..88d978fb43 100644 --- a/sources/scalac/transformer/UnCurry.java +++ b/sources/scalac/transformer/UnCurry.java @@ -88,7 +88,7 @@ public class UnCurry extends OwnerTransformer } default: if (tree1.symbol().isDefParameter()) { - tree1.type = global.definitions.functionType( + tree1.type = global.definitions.FUNCTION_TYPE( Type.EMPTY_ARRAY, tree1.type.widen()); return gen.Apply(gen.Select(tree1, global.definitions.FUNCTION_APPLY(0))); } else { @@ -131,7 +131,7 @@ public class UnCurry extends OwnerTransformer case ValDef(_, _, Tree tpe, Tree rhs): if (tree.symbol().isDefParameter()) { - Type newtype = global.definitions.functionType(Type.EMPTY_ARRAY, tpe.type); + Type newtype = global.definitions.FUNCTION_TYPE(Type.EMPTY_ARRAY, tpe.type); Tree tpe1 = gen.mkType(tpe.pos, newtype); return copy.ValDef(tree, tpe1, rhs).setType(newtype); } else { @@ -148,7 +148,7 @@ public class UnCurry extends OwnerTransformer Type ftype = fn.type; Tree fn1 = transform(fn); Tree[] args1 = transformArgs(tree.pos, args, ftype); - if (TreeInfo.methSymbol(fn1) == global.definitions.MATCH && + if (TreeInfo.methSymbol(fn1) == global.definitions.ANY_MATCH && !(args1[0] instanceof Tree.Visitor)) { switch (TreeInfo.methPart(fn1)) { case Select(Tree qual, Name name): diff --git a/sources/scalac/transformer/UnCurryPhase.java b/sources/scalac/transformer/UnCurryPhase.java index ce5bf61287..e8bdc1b77e 100644 --- a/sources/scalac/transformer/UnCurryPhase.java +++ b/sources/scalac/transformer/UnCurryPhase.java @@ -32,7 +32,7 @@ public class UnCurryPhase extends Phase implements Modifiers { */ public Type transformInfo(Symbol sym, Type tp0) { Type tp1 = uncurry(tp0); - if (sym.isDefParameter()) return global.definitions.functionType(Type.EMPTY_ARRAY, tp1); + if (sym.isDefParameter()) return global.definitions.FUNCTION_TYPE(Type.EMPTY_ARRAY, tp1); else return tp1; } diff --git a/sources/scalac/transformer/matching/CodeFactory.java b/sources/scalac/transformer/matching/CodeFactory.java index 832d75fc7b..32af74e511 100644 --- a/sources/scalac/transformer/matching/CodeFactory.java +++ b/sources/scalac/transformer/matching/CodeFactory.java @@ -48,12 +48,12 @@ class CodeFactory extends PatternTool { /** returns `List[ Tuple2[ scala.Int, ] ]' */ Type SeqTraceType( Type elemType ) { - return defs.listType(pairType(defs.INT_TYPE(), elemType)); + return defs.LIST_TYPE(pairType(defs.INT_TYPE(), elemType)); } /** returns `Iterator[ elemType ]' */ Type _seqIterType( Type elemType ) { - return defs.iteratorType(elemType); + return defs.ITERATOR_TYPE(elemType); } /** returns `' */ @@ -183,7 +183,7 @@ class CodeFactory extends PatternTool { } protected Tree Equals(Tree left, Tree right) { - Symbol fun = unit.global.definitions.EQEQ; + Symbol fun = unit.global.definitions.ANY_EQEQ; return gen.mkApply_V(gen.Select(left, fun), new Tree[]{right}); } @@ -199,7 +199,7 @@ class CodeFactory extends PatternTool { Type pairType( Type left, Type right ) { - return defs.tupleType(new Type[] { left, right } ); + return defs.TUPLE_TYPE(new Type[] { left, right } ); } Tree newPair( Tree left, Tree right ) { diff --git a/sources/scalac/transformer/matching/LeftTracerInScala.java b/sources/scalac/transformer/matching/LeftTracerInScala.java index d85d4b2e37..fec2d4dc9a 100644 --- a/sources/scalac/transformer/matching/LeftTracerInScala.java +++ b/sources/scalac/transformer/matching/LeftTracerInScala.java @@ -48,7 +48,7 @@ public class LeftTracerInScala extends TracerInScala { .toString() ), owner, 0) - .setType( defs.listType( elementType ) ) ; + .setType( defs.LIST_TYPE( elementType ) ) ; helpMap.put( realVar, helpVar ); @@ -65,11 +65,11 @@ public class LeftTracerInScala extends TracerInScala { cf.fresh.newName(Name.fromString( helpName )), owner, 0) - .setType( defs.listType( pat.type() )) ; + .setType( defs.LIST_TYPE( pat.type() )) ; Tree varDef = gen.ValDef( helpVar, gen.mkDefaultValue( cf.pos, - defs.listType( pat.type() )) + defs.LIST_TYPE( pat.type() )) //cf.ignoreValue( ) ); helpVarDefs.add( varDef ); diff --git a/sources/scalac/transformer/matching/PatternTool.java b/sources/scalac/transformer/matching/PatternTool.java index a34a53334e..c1e3c73483 100644 --- a/sources/scalac/transformer/matching/PatternTool.java +++ b/sources/scalac/transformer/matching/PatternTool.java @@ -20,16 +20,6 @@ import scalac.symtab.*; abstract class PatternTool { public static final Name RESULT_N = Name.fromString("$result"); - public static final Name SCALA_N = Name.fromString("scala"); - public static final Name BOOLEAN_N = Name.fromString("Boolean"); - public static final Name AND_N = Name.fromString("$amp$amp"); - public static final Name OR_N = Name.fromString("$bar$bar"); - public static final Name EQUALS_N = Name.fromString("$eq$eq"); - public static final Name SCALA_MATCHERROR_N = Name.fromString("scala.MatchError"); - public static final Name MATCHERROR_N = Name.fromString("MatchError"); - public static final Name FAIL_N = Name.fromString("fail"); - public static final Name LENGTH_N = Name.fromString("length"); - public static final Name APPLY_N = Name.fromString("apply"); /** the current compilation unit */ diff --git a/sources/scalac/transformer/matching/RightTracerInScala.java b/sources/scalac/transformer/matching/RightTracerInScala.java index 91d84091af..3f84b33aaf 100644 --- a/sources/scalac/transformer/matching/RightTracerInScala.java +++ b/sources/scalac/transformer/matching/RightTracerInScala.java @@ -108,7 +108,7 @@ public class RightTracerInScala extends TracerInScala { if( keepType ) helpVar.setType( realVar.type() ); else - helpVar.setType( defs.listType(elementType) ); + helpVar.setType( defs.LIST_TYPE(elementType) ); helpMap.put( realVar, helpVar ); @@ -291,7 +291,7 @@ public class RightTracerInScala extends TracerInScala { for( Iterator it = helpMap3.keySet().iterator(); it.hasNext(); ) { Symbol vsym = (Symbol) it.next(); Symbol hv = (Symbol) helpMap3.get( vsym ); - hv.setType( defs.listType( elementType ) ) ; + hv.setType( defs.LIST_TYPE( elementType ) ) ; Tree refv = gen.Ident(Position.FIRSTPOS, vsym); Tree refhv = gen.Ident(Position.FIRSTPOS, hv); res[ j++ ] = gen.Assign( refhv, refv ); diff --git a/sources/scalac/typechecker/Analyzer.java b/sources/scalac/typechecker/Analyzer.java index 6e5287dbd3..2d569a8425 100644 --- a/sources/scalac/typechecker/Analyzer.java +++ b/sources/scalac/typechecker/Analyzer.java @@ -582,13 +582,13 @@ public class Analyzer extends Transformer implements Modifiers, Kinds { private Type matchQualType(Tree fn) { switch (fn) { case Select(Tree qual, _): - if (fn.symbol() == definitions.MATCH) + if (fn.symbol() == definitions.ANY_MATCH) return qual.type.widen(); break; case TypeApply(Tree fn1, _): return matchQualType(fn1); case Ident(_): - if (fn.symbol() == definitions.MATCH) + if (fn.symbol() == definitions.ANY_MATCH) return context.enclClass.owner.typeOfThis(); break; } @@ -2013,7 +2013,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds { body = transform( body ); //assert body.type != null; if( TreeInfo.isSequenceValued( body ) ) { - vble.setType( definitions.listType(pt) ); + vble.setType( definitions.LIST_TYPE(pt) ); } else { vble.setType( body.type ); } @@ -2082,7 +2082,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds { case Throw(Tree expr): Tree expr1 = transform( expr, EXPRmode, definitions.JAVA_THROWABLE_TYPE()); - return gen.Select(tree.pos, expr1, definitions.THROW); + return gen.Select(tree.pos, expr1, definitions.JAVA_THROWABLE_THROW); case Return(Tree expr): if (!context.owner.isInitialized()) { @@ -2171,7 +2171,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds { switch (tpe) { case Ident(TypeNames.WILDCARD_STAR): expr1 = transform( - expr, mode & baseModes, definitions.seqType(pt)); + expr, mode & baseModes, definitions.SEQ_TYPE(pt)); Type[] elemtps = expr1.type.baseType(definitions.SEQ_CLASS). typeArgs(); Type elemtp = (elemtps.length == 1) ? elemtps[0] diff --git a/sources/scalac/typechecker/DeSugarize.java b/sources/scalac/typechecker/DeSugarize.java index c15e3b6291..4b9b5864af 100644 --- a/sources/scalac/typechecker/DeSugarize.java +++ b/sources/scalac/typechecker/DeSugarize.java @@ -151,7 +151,7 @@ public class DeSugarize implements Kinds, Modifiers { Type meth2fun(Type tp) { switch (tp) { case MethodType(Symbol[] params, Type restype): - return global.definitions.functionType( + return global.definitions.FUNCTION_TYPE( Symbol.type(params), meth2fun(restype)); default: return tp; diff --git a/sources/scalac/typechecker/Infer.java b/sources/scalac/typechecker/Infer.java index b23890f0d0..41f007059d 100644 --- a/sources/scalac/typechecker/Infer.java +++ b/sources/scalac/typechecker/Infer.java @@ -556,7 +556,7 @@ public class Infer implements Modifiers, Kinds { private Type normalize(Type tp) { switch (tp) { case MethodType(Symbol[] params, Type restype): - return global.definitions.functionType( + return global.definitions.FUNCTION_TYPE( Symbol.type(params), normalize(restype)); case PolyType(Symbol[] tparams, Type restype): if (tparams.length == 0) return normalize(restype); diff --git a/sources/scalac/typechecker/RefCheck.java b/sources/scalac/typechecker/RefCheck.java index 582b6e56f0..a2b4cfe140 100644 --- a/sources/scalac/typechecker/RefCheck.java +++ b/sources/scalac/typechecker/RefCheck.java @@ -613,7 +613,7 @@ public class RefCheck extends Transformer implements Modifiers, Kinds { private Tree toStringMethod(ClassSymbol clazz) { Symbol toStringSym = new TermSymbol( clazz.pos, Names.toString, clazz, OVERRIDE) - .setInfo(defs.TOSTRING.type()); + .setInfo(defs.ANY_TOSTRING.type()); clazz.info().members().enter(toStringSym); Tree[] fields = caseFields(clazz); Tree body; @@ -626,10 +626,10 @@ public class RefCheck extends Transformer implements Modifiers, Kinds { for (int i = 0; i < fields.length; i++) { String str = (i == fields.length - 1) ? ")" : ","; body = gen.Apply( - gen.Select(body, defs.STRING_PLUS_ANY), + gen.Select(body, defs.JAVA_STRING_PLUS), new Tree[]{fields[i]}); body = gen.Apply( - gen.Select(body, defs.STRING_PLUS_ANY), + gen.Select(body, defs.JAVA_STRING_PLUS), new Tree[]{gen.mkStringLit(clazz.pos, str)}); } } @@ -659,7 +659,7 @@ public class RefCheck extends Transformer implements Modifiers, Kinds { Tree cond = gen.TypeApply( gen.Select( gen.mkRef(clazz.pos, Type.localThisType, equalsParam), - defs.IS), + defs.ANY_IS), new Tree[]{gen.mkType(clazz.pos, testtp)}); Tree thenpart; @@ -670,7 +670,7 @@ public class RefCheck extends Transformer implements Modifiers, Kinds { Tree cast = gen.TypeApply( gen.Select( gen.mkRef(clazz.pos, Type.localThisType, equalsParam), - defs.AS), + defs.ANY_AS), new Tree[]{gen.mkType(clazz.pos, testtp)}); Symbol that1sym = new TermSymbol(clazz.pos, Names.that1, equalsSym, 0) .setType(testtp); @@ -717,7 +717,7 @@ public class RefCheck extends Transformer implements Modifiers, Kinds { private Tree hashCodeMethod(ClassSymbol clazz) { Symbol hashCodeSym = new TermSymbol( clazz.pos, Names.hashCode, clazz, OVERRIDE) - .setInfo(defs.HASHCODE.type()); + .setInfo(defs.ANY_HASHCODE.type()); clazz.info().members().enter(hashCodeSym); Tree[] fields = caseFields(clazz); Symbol getClassMethod = getNullaryMemberMethod(clazz.type(), Names.getClass); -- cgit v1.2.3