- Moved symbols from CodeFactory into Definitions

- Reorganized Definitions

13 files changed, 296 insertions, 308 deletions

diff --git a/sources/scala/tools/scalai/ExpressionCompiler.java b/sources/scala/tools/scalai/ExpressionCompiler.java
index 403e2b5a26..563ec09c1f 100644
--- a/sources/scala/tools/scalai/ExpressionCompiler.java
+++ b/sources/scala/tools/scalai/ExpressionCompiler.java
@@ -219,10 +219,10 @@ public class ExpressionCompiler {
     private Code vapply(Tree target, Symbol symbol, Tree[] trees) {
         // !!! optimize ?
         Code object = object(target);
-        if (symbol == definitions.BARBAR()) {
+        if (symbol == definitions.BOOLEAN_OR()) {
             return Code.Or(object, compute(trees[0]));
         }
-        if (symbol == definitions.AMPAMP()) {
+        if (symbol == definitions.BOOLEAN_AND()) {
             return Code.And(object, compute(trees[0]));
         }
         // !!! System.out.println("!!! method: " + Debug.show(symbol));
diff --git a/sources/scalac/symtab/Definitions.java b/sources/scalac/symtab/Definitions.java
index 481da7c6d0..1d0a4ee1a1 100644
--- a/sources/scalac/symtab/Definitions.java
+++ b/sources/scalac/symtab/Definitions.java
@@ -46,10 +46,6 @@ public class Definitions {
     public final Symbol SCALARUNTIME_CLASS;
     public final Type   SCALARUNTIME_TYPE;
 
-    /** the partial function class
-     */
-    public final Symbol PARTIALFUNCTION_CLASS;
-
     /** the null value
      */
     public final Symbol NULL;
@@ -101,7 +97,8 @@ public class Definitions {
 
     private Symbol OBJECT_TAG;
     public Symbol OBJECT_TAG() {
-        if (OBJECT_TAG == null) OBJECT_TAG = loadTerm(OBJECT_TYPE, Names.tag);
+        if (OBJECT_TAG == null)
+            OBJECT_TAG = loadTerm(OBJECT_CLASS, Names.tag);
         return OBJECT_TAG;
     }
 
@@ -136,9 +133,25 @@ public class Definitions {
     public final Symbol UNIT_CLASS;
     public final Type   UNIT_TYPE;
 
-    /** the array class
-     */
-    public final Symbol ARRAY_CLASS;
+    private Symbol BOOLEAN_OR;
+    private Symbol BOOLEAN_AND;
+    private Symbol BOOLEAN_NOT;
+
+    public Symbol BOOLEAN_OR() {
+        if (BOOLEAN_OR == null)
+            BOOLEAN_OR = loadTerm(BOOLEAN_CLASS, Names.BARBAR);
+        return BOOLEAN_OR;
+    }
+    public Symbol BOOLEAN_AND() {
+        if (BOOLEAN_AND == null)
+            BOOLEAN_AND = loadTerm(BOOLEAN_CLASS, Names.AMPAMP);
+        return BOOLEAN_AND;
+    }
+    public Symbol BOOLEAN_NOT() {
+        if (BOOLEAN_NOT == null)
+            BOOLEAN_NOT = loadTerm(BOOLEAN_CLASS, Names.BANG);
+        return BOOLEAN_NOT;
+    }
 
     /** types from java.lang
      */
@@ -152,47 +165,190 @@ public class Definitions {
     public final Symbol STRING_CLASS;
     public final Type   STRING_TYPE;
 
+    /** the scala.TupleX classes
+     */
+    public final int  TUPLE_count = 10;
+    public final Symbol[] TUPLE_CLASS = new Symbol[TUPLE_count];
+
+    public Type tupleType(Type[] args) {
+        assert 0 < args.length && args.length < TUPLE_count: args.length;
+	return getType(TUPLE_CLASS[args.length], args);
+    }
+
+    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 < 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 final Type[]   FUNCTION_TYPE = new Type[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];
+
     public Symbol FUNCTION_APPLY(int arity) {
-        assert arity < FUNCTION_count: arity;
+        assert 0 <= arity && arity < FUNCTION_count: arity;
         if (FUNCTION_APPLY[arity] == null)
-            FUNCTION_APPLY[arity] = loadTerm(FUNCTION_TYPE[arity],Names.apply);
+            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 });
+    }
+
+    private Symbol PARTIALFUNCTION_ISDEFINEDAT;
+
+    public Symbol PARTIALFUNCTION_ISDEFINEDAT() {
+        if (PARTIALFUNCTION_ISDEFINEDAT == null)
+            PARTIALFUNCTION_ISDEFINEDAT = loadTerm(PARTIALFUNCTION_CLASS, Names.isDefinedAt);
+        return PARTIALFUNCTION_ISDEFINEDAT;
+    }
+
     /** the scala.Ref class
      */
     public final Symbol REF_CLASS;
-    public final Type   REF_TYPE;
+
+    public Type refType(Type element) {
+        return getType(REF_CLASS, element);
+    }
 
     private Symbol REF_ELEM;
+
     public Symbol REF_ELEM() {
-        if (REF_ELEM == null) REF_ELEM = loadTerm(REF_TYPE, Names.elem);
+        if (REF_ELEM == null)
+            REF_ELEM = loadTerm(REF_CLASS, Names.elem);
         return REF_ELEM;
     }
 
+    /** the scala.List class
+     */
+    public final Symbol LIST_CLASS;
+    // !!! public final Symbol LIST_NIL_CLASS;
+    // !!! public final Symbol LIST_CONS_CLASS;
+
+    public Type listType(Type element) {
+        return getType(LIST_CLASS, element);
+    }
+
+    private Symbol LIST_ISEMPTY;
+    private Symbol LIST_HEAD;
+    private Symbol LIST_TAIL;
+
+    public Symbol LIST_ISEMPTY() {
+        if (LIST_ISEMPTY == null)
+            LIST_ISEMPTY = loadTerm(LIST_CLASS, Names.isEmpty);
+        return LIST_ISEMPTY;
+    }
+    public Symbol LIST_HEAD() {
+        if (LIST_HEAD == null)
+            LIST_HEAD = loadTerm(LIST_CLASS, Names.head);
+        return LIST_HEAD;
+    }
+    public Symbol LIST_TAIL() {
+        if (LIST_TAIL == null)
+            LIST_TAIL = loadTerm(LIST_CLASS, Names.tail);
+        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;
+
+    private Symbol MATCHERROR_FAIL;
+
+    public Symbol MATCHERROR_FAIL() {
+        if (MATCHERROR_FAIL == null)
+            MATCHERROR_FAIL = loadTerm(MATCHERROR, Names.fail);
+        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;
 
-    /** members of class Boolean
-     */
-    private Symbol BARBAR;
-    private Symbol AMPAMP;
-
-    public Symbol BARBAR() { loadBooleanMembers(); return BARBAR; }
-    public Symbol AMPAMP() { loadBooleanMembers(); return AMPAMP; }
-
     public final Symbol PATTERN_WILDCARD;
 
     public Definitions(Global global) {
@@ -251,9 +407,6 @@ public class Definitions {
         JAVA_OBJECT_TYPE = JAVA_OBJECT_CLASS.typeConstructor();
         JAVA_OBJECT_CLASS.setInfo(pparser.classCompletion);
 
-	// the scala.PartialFunction class
-	PARTIALFUNCTION_CLASS = getClass(Names.scala_PartialFunction);
-
         // the scala.ANYREF class
 	ANYREF_CLASS = new AliasTypeSymbol(
 	    Position.NOPOS, Names.AnyRef.toTypeName(),
@@ -328,13 +481,20 @@ public class Definitions {
 	STRING_TYPE = STRING_CLASS.typeConstructor();
 	STRING_CLASS.primaryConstructor().setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, STRING_TYPE));
 
-        for (int i = 0; i < FUNCTION_count; i++) {
-            FUNCTION_CLASS[i] = getClass(Names.scala_Function(i));
-            FUNCTION_TYPE[i] = FUNCTION_CLASS[i].typeConstructor();
+        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++)
+            FUNCTION_CLASS[i] = getClass(Names.scala_Function(i));
+	PARTIALFUNCTION_CLASS = getClass(Names.scala_PartialFunction);
         REF_CLASS = getClass(Names.scala_Ref);
-        REF_TYPE = REF_CLASS.typeConstructor();
+	LIST_CLASS = getClass(Names.scala_List);
+	ITERATOR_CLASS = getClass(Names.scala_Iterator);
+	ITERABLE_CLASS = getClass(Names.scala_Iterable);
 	SEQ_CLASS = getClass(Names.scala_Seq);
+	MATCHERROR = getModule(Names.scala_MatchError);
+	MATCHERROR_CLASS = getClass(Names.scala_MatchError);
 
 	/*
         ANY_PLUS_STRING = new TermSymbol(
@@ -489,40 +649,16 @@ public class Definitions {
 	return getClass(fullname).typeConstructor();
     }
 
-    private void loadBooleanMembers() {
-        if (BARBAR != null) return;
-        Symbol booleanStatics = getModule(Names.scala_Boolean);
-        BARBAR = BOOLEAN_TYPE.lookup(Names.BARBAR);
-        AMPAMP = BOOLEAN_TYPE.lookup(Names.AMPAMP);
-    }
-
-    private Symbol loadTerm(Type type, Name name) {
-        Symbol sym = type.lookup(name);
-        assert sym.isTerm() && !sym.isOverloaded(): type+"."+name+" -> "+sym;
+    private Symbol loadTerm(Symbol clasz, Name name) {
+        Symbol sym = clasz.lookup(name);
+        assert sym.isTerm() && !sym.isOverloaded(): clasz+"."+name+" -> "+sym;
         return sym;
     }
 
-    public Type arrayType(Type elemtpe) {
-        return Type.appliedType(ARRAY_CLASS.typeConstructor(), new Type[]{elemtpe});
+    private Type getType(Symbol clasz, Type arg) {
+	return getType(clasz, new Type[] { arg });
     }
-
-    public Type functionType(Type[] argtps, Type restp) {
-	Type[] argtps1 = new Type[argtps.length + 1];
-	System.arraycopy(argtps, 0, argtps1, 0, argtps.length);
-	argtps1[argtps.length] = restp;
-	return Type.appliedType(
-	    getType(Name.fromString("scala.Function" + argtps.length)),
-	    argtps1);
-    }
-
-    public Type partialFunctionType(Type argtpe, Type restpe) {
-	Type[] argtps1 = new Type[2];
-	argtps1[0] = argtpe;
-	argtps1[1] = restpe;
-	return Type.appliedType(PARTIALFUNCTION_CLASS.typeConstructor(), argtps1);
-    }
-
-    public Type seqType(Type argtpe) {
-	return Type.appliedType(getType(Names.scala_Seq), new Type[]{argtpe});
+    private Type getType(Symbol clasz, Type[] args) {
+        return Type.appliedType(clasz.typeConstructor(), args);
     }
 }
diff --git a/sources/scalac/transformer/Erasure.java b/sources/scalac/transformer/Erasure.java
index 4b606774ca..503135d14b 100644
--- a/sources/scalac/transformer/Erasure.java
+++ b/sources/scalac/transformer/Erasure.java
@@ -505,7 +505,7 @@ public class Erasure extends Transformer implements Modifiers {
 		Tree result = coerce(copy.Apply(tree, fun1, args1).setType(restpe), owntype);
 		if (isUnboxed(isSelectorType) && !isUnboxedArray(isSelectorType)) {
 		    Symbol primSym = primitives.getInstanceTestSymbol(isSelectorType);
-		    Symbol ampAmpSym = definitions.AMPAMP();
+		    Symbol ampAmpSym = definitions.BOOLEAN_AND();
 		    result = make.Apply(
 			result.pos,
 			make.Select(
diff --git a/sources/scalac/transformer/LambdaLiftPhase.java b/sources/scalac/transformer/LambdaLiftPhase.java
index 202508aef3..e9b19a3e6e 100644
--- a/sources/scalac/transformer/LambdaLiftPhase.java
+++ b/sources/scalac/transformer/LambdaLiftPhase.java
@@ -47,7 +47,8 @@ public class LambdaLiftPhase extends Phase implements Kinds, Modifiers {
                     tp1 = transform(tp, sym.owner());
             }
         }
-        if ((sym.flags & Modifiers.CAPTURED) != 0) return refType(tp1);
+        if ((sym.flags & Modifiers.CAPTURED) != 0)
+            return global.definitions.refType(tp1);
         else return tp1;
     }
 
@@ -151,12 +152,6 @@ public class LambdaLiftPhase extends Phase implements Kinds, Modifiers {
         //throw new ApplicationError("proxy " + fv + " in " + owner);
     }
 
-    /** The type scala.Ref[tp]
-     */
-    Type refType(Type tp) {
-        return Type.appliedType(global.definitions.REF_TYPE, new Type[]{tp});
-    }
-
     public Checker[] postCheckers(Global global) {
         return new Checker[] {
             new CheckSymbols(global),
diff --git a/sources/scalac/transformer/matching/AlgebraicMatcher.java b/sources/scalac/transformer/matching/AlgebraicMatcher.java
index e3f81e6ab1..eddcc95700 100644
--- a/sources/scalac/transformer/matching/AlgebraicMatcher.java
+++ b/sources/scalac/transformer/matching/AlgebraicMatcher.java
@@ -378,9 +378,9 @@ public class AlgebraicMatcher extends PatternMatcher {
         ts.append( gen.ValDef(root.symbol(), _m.selector ));
         ts.append( gen.ValDef(resultVar,
                               gen.mkDefaultValue(_m.pos, resultVar.info()) ));
-        ts.append( cf.If( toTree(root.and),
-                          gen.Ident( _m.pos, resultVar ),
-                          cf.ThrowMatchError( _m.pos, _m.resultType )));
+        ts.append( gen.If( toTree(root.and),
+                           gen.Ident( _m.pos, resultVar ),
+                           cf.ThrowMatchError( _m.pos, _m.resultType )));
         /*
             gen.If(
                 _m.pos,
diff --git a/sources/scalac/transformer/matching/Autom2Scala.java b/sources/scalac/transformer/matching/Autom2Scala.java
index cf836229c6..49b18f2943 100644
--- a/sources/scalac/transformer/matching/Autom2Scala.java
+++ b/sources/scalac/transformer/matching/Autom2Scala.java
@@ -154,9 +154,9 @@ public class Autom2Scala  {
 	    cf.gen.ValDef( this.hasnSym,
 			   cf._hasNext( _iter() ) ),
 	    cf.gen.ValDef( this.curSym,
-			   cf.If( gen.Ident( pos, hasnSym ),//cf._hasNext( _iter() ),
-				  cf._next( _iter() ),
-				  gen.mkDefaultValue(cf.pos,curSym.type()))),
+			   gen.If( gen.Ident( pos, hasnSym ),//cf._hasNext( _iter() ),
+				   cf._next( _iter() ),
+				   gen.mkDefaultValue(cf.pos,curSym.type()))),
 						 //cf.ignoreValue( curSym.type() )
 
 	    body });
@@ -209,9 +209,9 @@ public class Autom2Scala  {
 	    if( dfa.isSink( i ))
 		bodies[ i ] = run_finished( i ); // state won't change!
 	    else
-		bodies[ i ] = cf.If( cf.Negate( gen.Ident( pos, hasnSym )),//cf._not_hasNext( _iter() ),
-				     run_finished( i ),
-				     code_state_NEW( i ));
+		bodies[ i ] = gen.If( cf.Negate( gen.Ident( pos, hasnSym )),//cf._not_hasNext( _iter() ),
+				      run_finished( i ),
+				      code_state_NEW( i ));
 	}
 	if( optimize )
 	    return loadCurrentElem( gen.Switch( _state(),
@@ -222,9 +222,9 @@ public class Autom2Scala  {
 
 	Tree res = code_fail();
 	for( int i = dfa.nstates-2; i>= 0; i-- )
-	    res = cf.If( cf.Equals( _state(), gen.mkIntLit( cf.pos, i )),
-			 bodies[ i ] ,
-			 res );
+	    res = gen.If( cf.Equals( _state(), gen.mkIntLit( cf.pos, i )),
+			  bodies[ i ] ,
+			  res );
 
 	return loadCurrentElem( res );
 
@@ -302,9 +302,9 @@ public class Autom2Scala  {
 
 	    if( action != null ) {
 
-		stateBody = cf.If( currentMatches((Label) label ),
-				   action,
-				   stateBody);
+		stateBody = gen.If( currentMatches((Label) label ),
+				    action,
+				    stateBody);
 	    }
 	}
 	return stateBody;
diff --git a/sources/scalac/transformer/matching/CodeFactory.java b/sources/scalac/transformer/matching/CodeFactory.java
index bbdb42658d..20817acabd 100644
--- a/sources/scalac/transformer/matching/CodeFactory.java
+++ b/sources/scalac/transformer/matching/CodeFactory.java
@@ -21,116 +21,6 @@ class CodeFactory extends PatternTool {
 
     public int pos = Position.FIRSTPOS ;
 
-    static final Name TUPLE2_N       = Name.fromString("scala.Tuple2");
-
-    static final Name LEFT_N = Name.fromString("_1");
-    static final Name RIGHT_N = Name.fromString("_2");
-    static final Name HEAD_N       = Name.fromString("head");
-    static final Name TAIL_N       = Name.fromString("tail");
-    static final Name ISEMPTY_N        = Name.fromString("isEmpty");
-
-    Symbol refSym() { // delete Names.Ref
-	return defs.getType( Names.scala_Ref ).symbol() ;
-    }
-
-    Symbol seqSym() {
-	return defs.getType( Names.scala_Seq ).symbol() ;
-    }
-
-    Symbol intSym() {
-	return defs.getType( Names.scala_Int ).symbol() ;
-    }
-
-    Symbol tuple2Sym() {
-	return defs.getType( TUPLE2_N ).symbol() ;
-    }
-
-    Symbol tuple2Sym_left() {
-	return tuple2Sym().lookup( LEFT_N );
-    }
-
-    Symbol tuple2Sym_right() {
-	return tuple2Sym().lookup( RIGHT_N );
-    }
-
-    Symbol iteratorSym() {
-	return defs.getType( Names.scala_Iterator ).symbol() ;
-    }
-
-    Symbol seqListSym() {
-	return defs.getType( Names.scala_List ).symbol() ;
-    }
-
-    Symbol seqListSym_isEmpty() {
-	return seqListSym().lookup( ISEMPTY_N );
-    }
-
-    Symbol seqListSym_head() {
-	return seqListSym().lookup( HEAD_N );
-    }
-
-    Symbol seqListSym_tail() {
-	return seqListSym().lookup( TAIL_N );
-    }
-
-    Symbol seqListSym_length() {
-	return seqListSym().lookup( LENGTH_N );
-    }
-
-    /*
-    Symbol seqConsSym() {
-	return defs.getType( Names.scala_COLONCOLON ).symbol() ;
-    }
-
-    Symbol seqNilSym() {
-	return defs.getType( Names.scala_Nil ).symbol().module(); // no need for TypeApply anymore!x
-    }
-    */
-    Symbol seqIterSym() {
-	return defs.getType( Names.scala_Iterator ).symbol();
-    }
-
-    Symbol seqIterSym_next() {
-	return seqIterSym().lookup( Names.next );
-    }
-
-    Symbol seqIterSym_hasNext() {
-	return seqIterSym().lookup( Names.hasNext );
-    }
-    /*
-
-    Symbol seqTraceSym() {
-	return defs.getType( Name.fromString( "scala.SeqTrace" ) ).symbol();
-    }
-    Symbol seqTraceConsSym() {
-	return defs.getType( Name.fromString( "scala.SeqTraceCons" ) ).symbol();
-    }
-
-    Symbol seqTraceNilSym() {
-	return defs.getType( Name.fromString( "scala.SeqTraceNil" ) ).symbol();
-    }
-    */
-    Symbol iterableSym() {
-	return defs.getType( Names.scala_Iterable ).symbol();
-    }
-
-    Symbol newIterSym() {
-	return iterableSym().lookup( Names.elements );
-    }
-
-    Symbol andSym() {
-        return defs.BOOLEAN_CLASS.lookup(AND_N);
-    }
-
-    Symbol orSym() {
-        return defs.BOOLEAN_CLASS.lookup(OR_N);
-    }
-
-    Symbol failSym() {
-        return defs.SCALA_CLASS.lookup(MATCHERROR_N).lookup(FAIL_N);
-    }
-
-
     public CodeFactory( Unit unit, int pos ) {
 	super( unit );
 	this.pos = pos;
@@ -138,15 +28,6 @@ class CodeFactory extends PatternTool {
 
     // --------- these are new
 
-    /** If  ... pos, type is copied from thenBody
-     */
-    Tree If( Tree cond, Tree thenBody, Tree elseBody ) {
-	assert cond != null:"cond is null";
-	assert thenBody != null:"thenBody is null";
-	assert elseBody != null:"elseBody is null";
-	return gen.If( thenBody.pos, cond, thenBody, elseBody );
-    }
-
     /** a faked switch statement
      */
     Tree Switch( Tree selector,
@@ -160,39 +41,29 @@ class CodeFactory extends PatternTool {
 	Tree result = defaultBody;
 
 	for( int i = condition.length-1; i >= 0; i-- )
-	    result = If(condition[i], body[i], result);
+	    result = gen.If(condition[i], body[i], result);
 
 	return result ;
     }
 
     /** returns `List[ elemType ]' */
       Type SeqListType( Type elemType ) {
-            return Type.TypeRef( defs.SCALA_TYPE,
-                                 seqListSym(),
-                                 new Type[] { elemType });
+          return defs.listType(elemType);
       }
 
     /** returns  `List[ Tuple2[ scala.Int, <elemType> ] ]' */
       Type SeqTraceType( Type elemType ) {
-	  Type t = Type.TypeRef( defs.SCALA_TYPE,
-                                 seqListSym(),
-                                 new Type[] { pairType( defs.INT_TYPE,
-							elemType ) });
-	  //System.err.println("CodeFactory::SeqTraceType -"+ t );
-	  return t;
+          return defs.listType(pairType(defs.INT_TYPE, elemType));
       }
 
     /**  returns `Iterator[ elemType ]' */
     Type _seqIterType( Type elemType ) {
-	Symbol seqIterSym = defs.getType( Names.scala_Iterator ).symbol();
-
-	return Type.TypeRef( defs.SCALA_TYPE, seqIterSym(),
-			     new Type[] { elemType });
+        return defs.iteratorType(elemType);
     }
 
     /**  returns `<seqObj.elements>' */
     Tree newIterator( Tree seqObj, Type elemType ) {
-	return gen.mkApply__(gen.Select(seqObj, newIterSym()));
+	return gen.mkApply__(gen.Select(seqObj, defs.ITERABLE_ELEMENTS()));
     }
 
     /** returns code `<seqObj>.elements'
@@ -225,7 +96,7 @@ class CodeFactory extends PatternTool {
     // EXPERIMENTAL
     Tree newRef( Tree init ) {
 	//System.out.println( "hello:"+refSym().type() );
-	return gen.New(gen.mkPrimaryConstr(pos, refSym(),
+	return gen.New(gen.mkPrimaryConstr(pos, defs.REF_CLASS,
 			                    new Type[] { init.type() },
 			                    new Tree[] { init } ));
     }
@@ -234,7 +105,7 @@ class CodeFactory extends PatternTool {
      */
     Type getElemType_Sequence( Type tpe ) {
 	//System.err.println("getElemType_Sequence("+tpe.widen()+")");
-	Type tpe1 = tpe.widen().baseType( seqSym() );
+	Type tpe1 = tpe.widen().baseType( defs.SEQ_CLASS );
 
 	if( tpe1 == Type.NoType )
 	    throw new ApplicationError("arg "+tpe+" not subtype of Sequence[ A ]");
@@ -247,7 +118,7 @@ class CodeFactory extends PatternTool {
     Type getElemType_Iterator( Type tpe ) {
 	//System.err.println("getElemType_Iterator("+tpe+")");
 
-	Type tpe1 = tpe.widen().baseType( iteratorSym() );
+	Type tpe1 = tpe.widen().baseType( defs.ITERATOR_CLASS );
 
 	switch( tpe1 ) {
 	case TypeRef(_,_,Type[] args):
@@ -261,53 +132,46 @@ class CodeFactory extends PatternTool {
     /** `it.next()'
      */
     public Tree _next( Tree iter ) {
-	return gen.mkApply__(gen.Select(iter, seqIterSym_next()));
+	return gen.mkApply__(gen.Select(iter, defs.ITERATOR_NEXT()));
     }
 
     /** `it.hasNext()'
      */
     public Tree _hasNext( Tree iter ) {
-	return gen.mkApply__(gen.Select(iter, seqIterSym_hasNext()));
+	return gen.mkApply__(gen.Select(iter, defs.ITERATOR_HASNEXT()));
     }
 
     /** `!it.hasCur()'
      */
     public Tree _not_hasNext( Tree iter ) {
-	return gen.mkApply__(gen.Select(_hasNext(iter), notSym));
+	return gen.mkApply__(gen.Select(_hasNext(iter), defs.BOOLEAN_NOT()));
     }
 
       /** `trace.isEmpty'
        */
       public Tree isEmpty( Tree iter ) {
-          return gen.mkApply__(gen.Select(iter, seqListSym_isEmpty()));
+          return gen.mkApply__(gen.Select(iter, defs.LIST_ISEMPTY()));
       }
 
     Tree SeqTrace_headElem( Tree arg ) { // REMOVE SeqTrace
-	Tree t = gen.mkApply__(gen.Select(arg, seqListSym_head()));
-	return gen.mkApply__(gen.Select(t, tuple2Sym_right()));
+	Tree t = gen.mkApply__(gen.Select(arg, defs.LIST_HEAD()));
+	return gen.mkApply__(gen.Select(t, defs.TUPLE_FIELD(2, 2)));
     }
 
     Tree SeqTrace_headState( Tree arg ) { // REMOVE SeqTrace
-	Tree t = gen.mkApply__(gen.Select(arg, seqListSym_head()));
-	return gen.mkApply__(gen.Select(t, tuple2Sym_left()));
+	Tree t = gen.mkApply__(gen.Select(arg, defs.LIST_HEAD()));
+	return gen.mkApply__(gen.Select(t, defs.TUPLE_FIELD(2, 1)));
 
     }
 
     Tree SeqTrace_tail( Tree arg ) { // REMOVE SeqTrace
-	return gen.mkApply__(gen.Select(arg, seqListSym_tail()));
+	return gen.mkApply__(gen.Select(arg, defs.LIST_TAIL()));
     }
 
     /** `<seqlist>.head()'
      */
     Tree SeqList_head( Tree arg ) {
-	return gen.mkApply__(gen.Select(arg, seqListSym_head()));
-    }
-
-    /** return the analyzed type
-     */
-    public Type typeOf(Symbol sym) {
-        return sym.type();
-        //return sym.typeAt(unit.global.ANALYZER_PHASE.id);
+	return gen.mkApply__(gen.Select(arg, defs.LIST_HEAD()));
     }
 
      // unused
@@ -316,7 +180,7 @@ class CodeFactory extends PatternTool {
        case Literal(Object value):
        return gen.mkBooleanLit(tree.pos, !((Boolean)value).booleanValue());
        }
-       return gen.mkApply__(gen.Select(tree, notSym));
+       return gen.mkApply__(gen.Select(tree, defs.BOOLEAN_NOT()));
        }
 
     protected Tree And(Tree left, Tree right) {
@@ -328,7 +192,7 @@ class CodeFactory extends PatternTool {
 	case Literal(Object value):
 	    if (((Boolean)value).booleanValue()) return left;
         }
-        return gen.mkApply_V(gen.Select(left, andSym()), new Tree[]{right});
+        return gen.mkApply_V(gen.Select(left, defs.BOOLEAN_AND()), new Tree[]{right});
     }
 
     protected Tree Or(Tree left, Tree right) {
@@ -340,7 +204,7 @@ class CodeFactory extends PatternTool {
 	case Literal(Object value):
 	    if (!((Boolean)value).booleanValue()) return left;
         }
-        return gen.mkApply_V(gen.Select(left, orSym()), new Tree[]{right});
+        return gen.mkApply_V(gen.Select(left, defs.BOOLEAN_OR()), new Tree[]{right});
     }
 
     protected Tree Equals(Tree left, Tree right) {
@@ -350,7 +214,7 @@ class CodeFactory extends PatternTool {
 
     protected Tree ThrowMatchError(int pos, Type type) {
         return gen.mkApplyTV(
-			     gen.mkRef(pos, failSym()),
+			     gen.mkRef(pos, defs.MATCHERROR_FAIL()),
                              new Tree[]{gen.mkType(pos, type)},
                              new Tree[]{
                                  gen.mkStringLit(pos, unit.toString()),
@@ -360,13 +224,11 @@ class CodeFactory extends PatternTool {
 
 
     Type pairType( Type left, Type right ) {
-	return Type.TypeRef( defs.SCALA_TYPE,
-			     tuple2Sym() ,
-			     new Type[] { left, right } );
+	return defs.tupleType(new Type[] { left, right } );
     }
 
     Tree newPair( Tree left, Tree right ) {
- 	return gen.New(gen.mkPrimaryConstr(pos, tuple2Sym(),
+ 	return gen.New(gen.mkPrimaryConstr(pos, defs.TUPLE_CLASS[2],
 			                   new Type[] { left.type(), right.type() },
 			                   new Tree[] { left, right }));
 
diff --git a/sources/scalac/transformer/matching/LeftTracerInScala.java b/sources/scalac/transformer/matching/LeftTracerInScala.java
index 6f216aa677..debb09821a 100644
--- a/sources/scalac/transformer/matching/LeftTracerInScala.java
+++ b/sources/scalac/transformer/matching/LeftTracerInScala.java
@@ -184,17 +184,17 @@ public class LeftTracerInScala extends TracerInScala {
 	    Tree action = code_delta( i, (Label) label );
 
 	    if( action != null ) {
-		stateBody = cf.If( _cur_eq( _iter(), (Label) label ),
-				   action,
-				   stateBody);
+		stateBody = gen.If( _cur_eq( _iter(), (Label) label ),
+				    action,
+				    stateBody);
 	    }
 	}
-	stateBody = cf.If( cf.Negate( gen.Ident( cf.pos, hasnSym )),
-			   runFinished,
-			   stateBody );
-	return cf.If( cf.Equals( _state(), gen.mkIntLit(cf.pos, i )),
-		      stateBody ,
-		      elseBody );
+	stateBody = gen.If( cf.Negate( gen.Ident( cf.pos, hasnSym )),
+			    runFinished,
+			    stateBody );
+	return gen.If( cf.Equals( _state(), gen.mkIntLit(cf.pos, i )),
+		       stateBody ,
+		       elseBody );
     }
 
     Tree[] getTrace() {
diff --git a/sources/scalac/transformer/matching/PatternMatcher.java b/sources/scalac/transformer/matching/PatternMatcher.java
index 6e01a34373..4945360c93 100644
--- a/sources/scalac/transformer/matching/PatternMatcher.java
+++ b/sources/scalac/transformer/matching/PatternMatcher.java
@@ -686,7 +686,7 @@ public class PatternMatcher extends PatternTool {
     	else if (ncases == 1) {
     		switch (root.and.or) {
     			case ConstantPat(Object value):
-    				return cf.If(
+    				return gen.If(
     					cf.Equals(selector,
     						gen.mkLit(root.and.or.pos, value)),
     					bodyToTree(root.and.or.and),
@@ -921,7 +921,7 @@ public class PatternMatcher extends PatternTool {
                                     gen.Select(
                                         gen.mkAsInstanceOf(
                                             selector.duplicate(), node.type),
-                                        cf.seqListSym_length())),
+                                        defs.SEQ_LENGTH())),
                                 gen.mkIntLit(selector.pos, len))),
                         gen.mkBlock(
                             new Tree[]{
diff --git a/sources/scalac/transformer/matching/PatternTool.java b/sources/scalac/transformer/matching/PatternTool.java
index 89082c0947..a34a53334e 100644
--- a/sources/scalac/transformer/matching/PatternTool.java
+++ b/sources/scalac/transformer/matching/PatternTool.java
@@ -9,12 +9,10 @@
 package scalac.transformer.matching;
 
 
-import scalac.*;
-import scalac.ast.*;
+import scalac.Unit;
+import scalac.ast.TreeGen;
 import scalac.util.*;
 import scalac.symtab.*;
-import PatternNode.*;
-import Tree.*;
 
 /** this class takes care of tedious stuff which has nothing to do with
  *  matching
@@ -26,7 +24,6 @@ abstract class PatternTool {
     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 NOT_N = Name.fromString("$bang");
     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");
@@ -36,32 +33,19 @@ abstract class PatternTool {
 
     /** the current compilation unit
      */
-    Unit unit;
+    final Unit unit;
 
     /** the global fresh name creator
      */
-    FreshNameCreator fresh;
+    final FreshNameCreator fresh;
 
     /** the global definitions component
      */
-    Definitions defs;
+    final Definitions defs;
 
     /** the global tree generation component
      */
-    TreeGen gen;
-
-    /** the statics of class Boolean
-     */
-    Symbol statics; // REMOVE
-
-    /** the eqeq symbol
-     */
-    Symbol eqSymInt; // REMOVE
-    Symbol eqSymBool; // REMOVE
-
-    /** the eqeq symbol
-     */
-    Symbol notSym;
+    final TreeGen gen;
 
     // constructor
     public PatternTool( Unit unit ) {
@@ -69,10 +53,6 @@ abstract class PatternTool {
 	this.fresh = unit.global.freshNameCreator;
 	this.gen = unit.global.treeGen;
 	this.defs = unit.global.definitions;
-
-	this.notSym = defs.BOOLEAN_CLASS.lookup/*Term*/( NOT_N );
-	assert !(notSym instanceof NoSymbol) : " Boolean.! not found ";
-
-    } // PatternTool( Unit unit, .... )
+    }
 
 } // class PatternTool
diff --git a/sources/scalac/transformer/matching/RightTracerInScala.java b/sources/scalac/transformer/matching/RightTracerInScala.java
index 084050ea56..2be85bc9c4 100644
--- a/sources/scalac/transformer/matching/RightTracerInScala.java
+++ b/sources/scalac/transformer/matching/RightTracerInScala.java
@@ -192,15 +192,15 @@ public class RightTracerInScala extends TracerInScala  {
 	}
 
 
-	Tree t3 = cf.If( cf.isEmpty( _iter() ),
-			 run_finished( 0 ),
-			 gen.mkBlock( new Tree[] {
-			     gen.ValDef( targetSym,
-					 cf.SeqTrace_headState( gen.Ident( pos, iterSym))),
-			     gen.ValDef( elemSym,
-					 cf.SeqTrace_headElem( gen.Ident( pos, iterSym))),
+	Tree t3 = gen.If( cf.isEmpty( _iter() ),
+			  run_finished( 0 ),
+			  gen.mkBlock( new Tree[] {
+			      gen.ValDef( targetSym,
+					  cf.SeqTrace_headState( gen.Ident( pos, iterSym))),
+			      gen.ValDef( elemSym,
+					  cf.SeqTrace_headElem( gen.Ident( pos, iterSym))),
 
-			     body }));
+			      body }));
 
 	/*
 	  t3 = gen.mkBlock( new Tree[] {
@@ -231,17 +231,17 @@ public class RightTracerInScala extends TracerInScala  {
 	    Integer targetL  = (Integer) it.next();
 	    Integer targetR  = (Integer) hmap.get( targetL );
 
-	    stateBody = cf.If( cf.Equals( gen.Ident( pos, targetSym ),
-					  gen.mkIntLit( cf.pos, targetL )),
-			       callFun( new Tree[] {
-				   cf.SeqTrace_tail( _iter() ),
-				   gen.mkIntLit( cf.pos, targetR ) }),
-			       stateBody );
+	    stateBody = gen.If( cf.Equals( gen.Ident( pos, targetSym ),
+					   gen.mkIntLit( cf.pos, targetL )),
+			        callFun( new Tree[] {
+				    cf.SeqTrace_tail( _iter() ),
+				    gen.mkIntLit( cf.pos, targetR ) }),
+			        stateBody );
 	}
 
-	return cf.If( cf.Equals( _state(), gen.mkIntLit( cf.pos, 0 )),
-		      stateBody ,
-		      elseBody );
+	return gen.If( cf.Equals( _state(), gen.mkIntLit( cf.pos, 0 )),
+		       stateBody ,
+		       elseBody );
 
     }
 
@@ -272,15 +272,15 @@ public class RightTracerInScala extends TracerInScala  {
 
 	    if( action != null ) {
 
-		stateBody = cf.If( _cur_eq( _iter(), (Label) label ),
-				   action,
-				   stateBody);
+		stateBody = gen.If( _cur_eq( _iter(), (Label) label ),
+				    action,
+				    stateBody);
 	    }
 	}
 
-	return cf.If( cf.Equals( _state(), gen.mkIntLit( cf.pos, i )),
-		      stateBody ,
-		      elseBody );
+	return gen.If( cf.Equals( _state(), gen.mkIntLit( cf.pos, i )),
+		       stateBody ,
+		       elseBody );
     }
 
     /** returns a Tree whose type is boolean.
diff --git a/sources/scalac/typechecker/RefCheck.java b/sources/scalac/typechecker/RefCheck.java
index 3d1461272c..080a5b7441 100644
--- a/sources/scalac/typechecker/RefCheck.java
+++ b/sources/scalac/typechecker/RefCheck.java
@@ -679,7 +679,7 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 		    gen.mkRef(clazz.pos, Type.localThisType, that1sym), 0));
 	    for (int i = 1; i < fields.length; i++) {
 		cmp = gen.Apply(
-		    gen.Select(cmp, defs.AMPAMP()),
+		    gen.Select(cmp, defs.BOOLEAN_AND()),
 		    new Tree[]{
 			eqOp(
 			    fields[i],
diff --git a/sources/scalac/util/Names.java b/sources/scalac/util/Names.java
index fc7d44ff9f..6492127b1f 100644
--- a/sources/scalac/util/Names.java
+++ b/sources/scalac/util/Names.java
@@ -14,6 +14,8 @@ public class Names {
     private static final String LOCAL_PREFIX = "local$";
     private static final String OUTER_PREFIX = "outer$";
     private static final String SUPER_PREFIX = "super$";
+    private static final String TUPLE_FIELD_PREFIX = "_";
+    private static final String scala_Tuple_PREFIX = "scala.Tuple";
     private static final String scala_Function_PREFIX = "scala.Function";
 
     public static Name LOCAL(Symbol clasz) {
@@ -40,6 +42,14 @@ public class Names {
         return Name.fromString(SUPER_PREFIX + method.name);
     }
 
+    public static Name TUPLE_FIELD(int index) {
+        return Name.fromString(TUPLE_FIELD_PREFIX + index);
+    }
+
+    public static Name scala_Tuple(int arity) {
+        return Name.fromString(scala_Tuple_PREFIX + arity);
+    }
+
     public static Name scala_Function(int arity) {
         return Name.fromString(scala_Function_PREFIX + arity);
     }
@@ -106,6 +116,7 @@ public class Names {
     public static final Name box = Name.fromString("box");
     public static final Name elem = Name.fromString("elem");
     public static final Name elements = Name.fromString("elements");
+    public static final Name fail = Name.fromString("fail");
     public static final Name false_ = Name.fromString("false");
     public static final Name filter = Name.fromString("filter");
     public static final Name flatmap = Name.fromString("flatMap");
@@ -113,8 +124,10 @@ public class Names {
     public static final Name getClass = Name.fromString("getClass");
     public static final Name hashCode = Name.fromString("hashCode");
     public static final Name hasNext = Name.fromString("hasNext");
+    public static final Name head = Name.fromString("head");
     public static final Name isInstanceOf = Name.fromString("isInstanceOf");
     public static final Name isDefinedAt = Name.fromString("isDefinedAt");
+    public static final Name isEmpty = Name.fromString("isEmpty");
     public static final Name java = Name.fromString("java");
     public static final Name java_lang = Name.fromString("java.lang");
     public static final Name java_lang_Object = Name.fromString("java.lang.Object");
@@ -149,6 +162,7 @@ public class Names {
     public static final Name scala_Iterator = Name.fromString("scala.Iterator");
     public static final Name scala_List = Name.fromString("scala.List");
     public static final Name scala_Long = Name.fromString("scala.Long");
+    public static final Name scala_MatchError = Name.fromString("scala.MatchError");
     public static final Name scala_Nil = Name.fromString("scala.Nil");
     public static final Name scala_Object = Name.fromString("scala.Object");
     public static final Name scala_PartialFunction = Name.fromString("scala.PartialFunction");
@@ -163,6 +177,7 @@ public class Names {
     public static final Name scala_runtime_RunTime = Name.fromString("scala.runtime.RunTime");
     public static final Name eq = Name.fromString("eq");
     public static final Name equals = Name.fromString("equals");
+    public static final Name tail = Name.fromString("tail");
     public static final Name toString = Name.fromString("toString");
     public static final Name that = Name.fromString("that");
     public static final Name that1 = Name.fromString("that1");