added Autom2Scala and related methods (pattern ...

added Autom2Scala and related methods (pattern matching)

1 files changed, 183 insertions, 103 deletions

diff --git a/sources/scalac/transformer/matching/CodeFactory.java b/sources/scalac/transformer/matching/CodeFactory.java
index 0c0b6e89e8..92a8d4ec8f 100644
--- a/sources/scalac/transformer/matching/CodeFactory.java
+++ b/sources/scalac/transformer/matching/CodeFactory.java
@@ -20,9 +20,89 @@ import Tree.*;
 
 class CodeFactory extends PatternTool {
 
-     public CodeFactory( Unit unit, Infer infer ) {
-            super( unit, infer );
-     }
+    static final Name SEQ_ITER_N   = Name.fromString("scala.SequenceIterator");
+    static final Name HAS_CUR_N    = Name.fromString("hasCur");
+    static final Name CUR_N        = Name.fromString("cur");
+    static final Name NEXT_N       = Name.fromString("next");
+
+    /** symbol of `scala.SequenceIterator'
+     */
+    Symbol seqIterSym;
+
+    Symbol curSym;
+    Symbol hasCurSym;
+    Symbol nextSym;
+
+    public CodeFactory( Unit unit, Infer infer ) {
+	super( unit, infer );
+
+	this.seqIterSym = defs.getType( SEQ_ITER_N ).symbol();
+	Scope scp = seqIterSym.members();
+	curSym = scp.lookup/*Term*/ ( CUR_N );
+	assert !( curSym == Symbol.NONE ) : "did not find cur";
+    }
+
+    // --------- these are new
+
+    /** If  ... pos, type is copied from thenBody
+     */
+    Tree If( Tree cond, Tree thenBody, Tree elseBody ) {
+	//assert( thenBody.type().equals( elseBody.type() )
+	//       || thenBody.type().isSubType( elseBody.type() )
+	//        /*|| elseBody.type().isSubType( thenBody.type()  BUG  */)
+	//    : "you try to construct a naughty if "
+	//     + "thenBody: "+thenBody.type+" elseBody:"+elseBody.type;
+	assert cond != null:"cond is null";
+	assert thenBody != null:"thenBody is null";
+	assert elseBody != null:"elseBody is null";
+	return make.If( thenBody.pos,
+			cond,
+			thenBody,
+			elseBody ).setType( elseBody.type() );
+    }
+
+    /**                       `SequenceIterator[ elemType ]' // TODO: Move to TypeFactory
+     */
+    Type _seqIterType( Type elemType ) {
+	return Type.TypeRef( defs.SCALA_TYPE/*PREFIX*/,
+			     seqIterSym,
+			     new Type[] { elemType });
+    }
+
+    // the caller needs to set the type !
+    Tree  _applyNone( Tree arg ) {
+	return make.Apply(Position.NOPOS, arg, Tree.EMPTY_ARRAY );
+    }
+
+    // todo: more defensive checking
+    Type getElemType( Type seqType ) {
+	Type[] args = seqType.typeArgs(); /*use typeArgs instead of args*/
+	assert (args.length==1);
+	return args[ 0 ];
+
+    }
+
+    /** `it.cur()'
+     */
+    Tree _cur( Tree iter ) {
+	Type elemType = getElemType( iter.type() );
+	return _applyNone( gen.Select( iter, curSym ).setType( elemType ))
+	    .setType( elemType );
+    }
+
+    /** `it.hasCur()'
+     */
+    public Tree _hascur( Tree iter ) {
+	return _applyNone( gen.Select( iter, hasCurSym ))
+	    .setType( defs.BOOLEAN_TYPE );
+    }
+
+    /** `!it.hasCur()'
+     */
+    public Tree _noMoreCur( Tree iter ) {
+	return _applyNone( gen.Select( _hascur( iter ), notSym ))
+	    .setType( defs.BOOLEAN_TYPE );
+    }
 
     /** return the analyzed type
      */
@@ -43,152 +123,152 @@ class CodeFactory extends PatternTool {
             return ts[0];
         else if (ts.length > 1)
             switch (ts[ts.length - 1]) {
-                case Block(Tree[] ts0):
-                    Tree[] ts1 = new Tree[ts0.length + ts.length - 1];
-                    System.arraycopy(ts, 0, ts1, 0, ts.length - 1);
-                    System.arraycopy(ts0, 0, ts1, ts.length - 1, ts0.length);
-                    return Block(pos, ts1, tpe);
+	    case Block(Tree[] ts0):
+		Tree[] ts1 = new Tree[ts0.length + ts.length - 1];
+		System.arraycopy(ts, 0, ts1, 0, ts.length - 1);
+		System.arraycopy(ts0, 0, ts1, ts.length - 1, ts0.length);
+		return Block(pos, ts1, tpe);
             }
         return make.Block(pos, ts).setType(tpe);
     }
 
     /* // unused
-    protected Tree Negate(Tree tree) {
-        switch (tree) {
-            case Literal(Object value):
-                return gen.mkBooleanLit(tree.pos, !((Boolean)value).booleanValue());
-        }
-        return make.Apply(
-                tree.pos,
-                gen.Select(tree, NOT_N),
-                Tree.EMPTY_ARRAY).setType(defs.BOOLEAN_TYPE);
-    }
+       protected Tree Negate(Tree tree) {
+       switch (tree) {
+       case Literal(Object value):
+       return gen.mkBooleanLit(tree.pos, !((Boolean)value).booleanValue());
+       }
+       return make.Apply(
+       tree.pos,
+       gen.Select(tree, NOT_N),
+       Tree.EMPTY_ARRAY).setType(defs.BOOLEAN_TYPE);
+       }
     */
     protected Tree And(Tree left, Tree right) {
         switch (left) {
-            case Literal(Object value):
-                return ((Boolean)value).booleanValue() ? right : left;
+	case Literal(Object value):
+	    return ((Boolean)value).booleanValue() ? right : left;
         }
         switch (right) {
-            case Literal(Object value):
-                if (((Boolean)value).booleanValue()) return left;
+	case Literal(Object value):
+	    if (((Boolean)value).booleanValue()) return left;
         }
         Symbol fun = left.type.lookup(AND_N);
         return make.Apply(
-                left.pos,
-                make.Select(
-                    left.pos,
-                    left,
-                    AND_N).setType(typeOf(fun)).setSymbol(fun),
-                new Tree[]{right}).setType(defs.BOOLEAN_TYPE);
+			  left.pos,
+			  make.Select(
+				      left.pos,
+				      left,
+				      AND_N).setType(typeOf(fun)).setSymbol(fun),
+			  new Tree[]{right}).setType(defs.BOOLEAN_TYPE);
     }
 
     protected Tree Or(Tree left, Tree right) {
         switch (left) {
-            case Literal(Object value):
-                return ((Boolean)value).booleanValue() ? left : right;
+	case Literal(Object value):
+	    return ((Boolean)value).booleanValue() ? left : right;
         }
         switch (right) {
-            case Literal(Object value):
-                if (!((Boolean)value).booleanValue()) return left;
+	case Literal(Object value):
+	    if (!((Boolean)value).booleanValue()) return left;
         }
         Symbol fun = left.type.lookup(OR_N);
         return make.Apply(
-                left.pos,
-                make.Select(
-                    left.pos,
-                    left,
-                    OR_N).setType(typeOf(fun)).setSymbol(fun),
-                new Tree[]{right}).setType(defs.BOOLEAN_TYPE);
+			  left.pos,
+			  make.Select(
+				      left.pos,
+				      left,
+				      OR_N).setType(typeOf(fun)).setSymbol(fun),
+			  new Tree[]{right}).setType(defs.BOOLEAN_TYPE);
     }
 
     protected Tree Is(Tree tree, Type type) {
         return
             make.Apply(
-                tree.pos,
-                make.TypeApply(
-                    tree.pos,
-                    make.Select(
-                        tree.pos,
-                        tree,
-                        defs.IS.name).setType(typeOf(defs.IS)).setSymbol(defs.IS),
-                    new Tree[]{gen.mkType(tree.pos, type)})
-                .setType(Type.MethodType(Symbol.EMPTY_ARRAY, defs.BOOLEAN_TYPE)),
-                Tree.EMPTY_ARRAY).setType(defs.BOOLEAN_TYPE);
+		       tree.pos,
+		       make.TypeApply(
+				      tree.pos,
+				      make.Select(
+						  tree.pos,
+						  tree,
+						  defs.IS.name).setType(typeOf(defs.IS)).setSymbol(defs.IS),
+				      new Tree[]{gen.mkType(tree.pos, type)})
+		       .setType(Type.MethodType(Symbol.EMPTY_ARRAY, defs.BOOLEAN_TYPE)),
+		       Tree.EMPTY_ARRAY).setType(defs.BOOLEAN_TYPE);
     }
 
     protected Tree As(Tree tree, Type type) {
         return
             make.Apply(
-                tree.pos,
-                make.TypeApply(
-                    tree.pos,
-                    make.Select(
-                        tree.pos,
-                        tree,
-                        defs.AS.name).setType(typeOf(defs.AS)).setSymbol(defs.AS),
-                    new Tree[]{gen.mkType(tree.pos, type)})
-                .setType(Type.MethodType(Symbol.EMPTY_ARRAY, type)),
-                Tree.EMPTY_ARRAY).setType(type);
+		       tree.pos,
+		       make.TypeApply(
+				      tree.pos,
+				      make.Select(
+						  tree.pos,
+						  tree,
+						  defs.AS.name).setType(typeOf(defs.AS)).setSymbol(defs.AS),
+				      new Tree[]{gen.mkType(tree.pos, type)})
+		       .setType(Type.MethodType(Symbol.EMPTY_ARRAY, type)),
+		       Tree.EMPTY_ARRAY).setType(type);
     }
 
     protected Tree Equals(Tree left, Tree right) {
         Symbol fun = left.type.lookup(EQUALS_N);
         switch (typeOf(fun)) {
-            case OverloadedType(Symbol[] alts, Type[] alttypes):
-                //System.out.println("**** " + left.type);
-                Tree t = make.Select(left.pos, left, EQUALS_N);
-                //for (int i = 0; i < alttypes.length; i++)
-                //    System.out.println(alts[i] + ": " + alttypes[i]);
-                infer.methodAlternative(t, alts, alttypes,
-                    new Type[]{right.type}, defs.BOOLEAN_TYPE);
-                return make.Apply(left.pos, t, new Tree[]{right}).setType(defs.BOOLEAN_TYPE);
-            default:
-                //System.out.println("#### " + left.type + ": " + fun);
-                return make.Apply(
-                    left.pos,
-                    make.Select(
-                        left.pos,
-                        left,
-                        EQUALS_N).setType(typeOf(fun)).setSymbol(fun),
-                    new Tree[]{right}).setType(defs.BOOLEAN_TYPE);
+	case OverloadedType(Symbol[] alts, Type[] alttypes):
+	    //System.out.println("**** " + left.type);
+	    Tree t = make.Select(left.pos, left, EQUALS_N);
+	    //for (int i = 0; i < alttypes.length; i++)
+	    //    System.out.println(alts[i] + ": " + alttypes[i]);
+	    infer.methodAlternative(t, alts, alttypes,
+				    new Type[]{right.type}, defs.BOOLEAN_TYPE);
+	    return make.Apply(left.pos, t, new Tree[]{right}).setType(defs.BOOLEAN_TYPE);
+	default:
+	    //System.out.println("#### " + left.type + ": " + fun);
+	    return make.Apply(
+			      left.pos,
+			      make.Select(
+					  left.pos,
+					  left,
+					  EQUALS_N).setType(typeOf(fun)).setSymbol(fun),
+			      new Tree[]{right}).setType(defs.BOOLEAN_TYPE);
         }
     }
 
     protected Tree ThrowMatchError(int pos, Type type) {
         Symbol matchErrorModule = defs.SCALA.members().lookup(MATCHERROR_N);
         outer: switch (typeOf(matchErrorModule)) {
-            case OverloadedType(Symbol[] alts, Type[] alttypes):
-                for (int i = 0; i < alts.length; i++)
-                    switch (alttypes[i]) {
-                        case TypeRef(_, _, _):
-                            matchErrorModule = alts[i];
-                            break outer;
-                    }
+	case OverloadedType(Symbol[] alts, Type[] alttypes):
+	    for (int i = 0; i < alts.length; i++)
+		switch (alttypes[i]) {
+		case TypeRef(_, _, _):
+		    matchErrorModule = alts[i];
+		    break outer;
+		}
         }
         Symbol failMethod = typeOf(matchErrorModule).lookup(FAIL_N);
         return
-        make.Apply(
-            pos,
-            make.TypeApply(
-               pos,
-               make.Select(
-                pos,
-                make.Select(
-                    pos,
-                    make.Ident(pos, Names.scala).setType(typeOf(defs.SCALA)).setSymbol(defs.SCALA),
-                    MATCHERROR_N)
-                   .setSymbol(matchErrorModule)
-                   .setType(typeOf(matchErrorModule)),
-                FAIL_N).setType(typeOf(failMethod)).setSymbol(failMethod),
-                new Tree[]{gen.mkType(pos, type)})
-              .setType(((Type.PolyType) typeOf(failMethod)).result.subst(
-                    typeOf(failMethod).typeParams(),
-                    new Type[]{type})),
-            new Tree[]{
-                make.Literal(pos, unit.toString()).setType(defs.STRING_TYPE),
-                make.Literal(pos, new Integer(Position.line(pos))).setType(defs.INT_TYPE)
-            }).setType(type);
+	    make.Apply(
+		       pos,
+		       make.TypeApply(
+				      pos,
+				      make.Select(
+						  pos,
+						  make.Select(
+							      pos,
+							      make.Ident(pos, Names.scala).setType(typeOf(defs.SCALA)).setSymbol(defs.SCALA),
+							      MATCHERROR_N)
+						  .setSymbol(matchErrorModule)
+						  .setType(typeOf(matchErrorModule)),
+						  FAIL_N).setType(typeOf(failMethod)).setSymbol(failMethod),
+				      new Tree[]{gen.mkType(pos, type)})
+		       .setType(((Type.PolyType) typeOf(failMethod)).result.subst(
+										  typeOf(failMethod).typeParams(),
+										  new Type[]{type})),
+		       new Tree[]{
+			   make.Literal(pos, unit.toString()).setType(defs.STRING_TYPE),
+			   make.Literal(pos, new Integer(Position.line(pos))).setType(defs.INT_TYPE)
+		       }).setType(type);
     }
 
 }