- Normalized member names of class Definition

- Cleaned code of Definition

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("<<compiled code>>", 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, <elemType> ] ]' */
       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 `<seqObj.elements>' */
@@ -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);