- Moved symbols from CodeFactory into Definitions

- Reorganized Definitions

1 files changed, 24 insertions, 162 deletions

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 }));