From 0f26e2f6ed6e8cb73b7c192902b79e0bbf1ec0c9 Mon Sep 17 00:00:00 2001 From: paltherr Date: Tue, 14 Oct 2003 08:48:13 +0000 Subject: - Moved symbols from CodeFactory into Definitions - Reorganized Definitions --- sources/scalac/symtab/Definitions.java | 254 ++++++++++++++++----- sources/scalac/transformer/Erasure.java | 2 +- sources/scalac/transformer/LambdaLiftPhase.java | 9 +- .../transformer/matching/AlgebraicMatcher.java | 6 +- .../scalac/transformer/matching/Autom2Scala.java | 24 +- .../scalac/transformer/matching/CodeFactory.java | 186 ++------------- .../transformer/matching/LeftTracerInScala.java | 18 +- .../transformer/matching/PatternMatcher.java | 4 +- .../scalac/transformer/matching/PatternTool.java | 34 +-- .../transformer/matching/RightTracerInScala.java | 46 ++-- sources/scalac/typechecker/RefCheck.java | 2 +- sources/scalac/util/Names.java | 15 ++ 12 files changed, 294 insertions(+), 306 deletions(-) (limited to 'sources/scalac') 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, ] ]' */ 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 `' */ Tree newIterator( Tree seqObj, Type elemType ) { - return gen.mkApply__(gen.Select(seqObj, newIterSym())); + return gen.mkApply__(gen.Select(seqObj, defs.ITERABLE_ELEMENTS())); } /** returns code `.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())); } /** `.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"); -- cgit v1.2.3