ant task fixed up,

symbol classes public
testregtraverser obsolete

3 files changed, 48 insertions, 163 deletions

diff --git a/sources/scala/tools/scala4ant/AntAdaptor.scala b/sources/scala/tools/scala4ant/AntAdaptor.scala
index 556708292f..19fab5d32d 100644
--- a/sources/scala/tools/scala4ant/AntAdaptor.scala
+++ b/sources/scala/tools/scala4ant/AntAdaptor.scala
@@ -40,25 +40,11 @@ package scala.tools.scala4ant {
         scala.tools.scalac.Main.main1( false, args );
       } catch {
         case e:Throwable => {
-          ex = e;
           result = false;
-          try {                             // fall back on exec
-            val commands = new Array[String](args.length+2) ;
-	    commands(0) = "java";
-	    commands(1) = "scala.tools.scalac.Main";
-	    System.arraycopy(args,0,commands,2,args.length);
-	    val exe = new Execute();
-	    exe.setCommandline(commands);
-	    //result = exe.execute() == 0;
-            result = true;
-          } catch {
-            case e:Throwable => {
-              result = false;
-              ex = e;
-            }
-          }
-          if( !result ) throw new BuildException( ex.getMessage() );
+          ex = e;
         }
+        ex.printStackTrace();
+        if( !result ) throw new BuildException("exception occurred:"+ex.getClass());
       }
       result;
     }
diff --git a/sources/scala/tools/scalac/transformer/TransMatch.scala b/sources/scala/tools/scalac/transformer/TransMatch.scala
index ccc0f14a2d..7826907748 100644
--- a/sources/scala/tools/scalac/transformer/TransMatch.scala
+++ b/sources/scala/tools/scalac/transformer/TransMatch.scala
@@ -13,13 +13,11 @@ import scalac._;
 import scalac.ast._;
 import scalac.symtab._;
 import scalac.util._;       // Names
-import Tree._;
 
 import scalac.transformer.{ OwnerTransformer => scalac_transformer_OwnerTransformer };
 
 import scalac.transformer.matching.PartialMatcher ;
 import scalac.transformer.matching.PatternMatcher ;
-import scalac.transformer.matching.TestRegTraverser ;
 import scalac.transformer.matching.AlgebraicMatcher ;
 
 /** A transformer for expanding match expressions into
@@ -43,25 +41,6 @@ class TransMatch( global:scalac_Global )
     super.apply( cunit );
   }
 
-    import Tree._ ;
-/*
-    def singleSeq(t:Array[Tree]) = {
-      t.length == 1 && t(0).isInstaceOf[Sequence] && val ts = Iterator.fromArray( t );
-
-      (( trees.length == 1 ) &&
-       ( trees( 0 ) match {
-         case Sequence( trees2 ) =>
-           (( trees2.length == 1 ) &&
-            ( trees2( 0 ) match {
-              case Sequence( trees3 )=>
-                true;
-              case _ => isRegular( trees2 );
-              }
-             })) || ( trees2.length != 0 ) && isRegular( trees2 )
-           case _ => false
-         })) ||
-    }
-*/
     def isRegular(ps:Array[Tree]):Boolean = {
       var res = false;
       val pats = scala.Iterator.fromArray( ps );
@@ -71,18 +50,47 @@ class TransMatch( global:scalac_Global )
     }
 
     def isRegular(pat:Tree):Boolean = pat match {
-      case Alternative(_)          => true;
-      case Bind( n, pat1 ) =>
-        TreeInfo.isNameOfStarPattern( n ) || TreeInfo.isEmptySequence( pat1 )
-      case Tree$Ident(n)                =>  TreeInfo.isNameOfStarPattern( n )
-      case Sequence( trees )       =>
-        true;//( trees.length != 0 )||isRegular( trees );
-      case Apply( fn, trees ) =>
+      case Tree$Alternative(_)          =>  true
+      case Tree$Bind( n, pat1 )              =>
+        TreeInfo.isNameOfStarPattern( n )
+      || TreeInfo.isEmptySequence( pat1 )
+      || isRegular( pat1 )
+      case Tree$Ident(n)                =>  false
+      case Tree$Sequence( trees )       =>
+        ( trees.length == 0 ) || isRegular( trees );
+      case Tree$Apply( fn, trees )      =>
         isRegular( trees ) &&
         !((trees.length == 1) && TreeInfo.isEmptySequence( trees( 0 )))
-      case _ => false;
+      case Tree$Literal(_)              => false;
+      case Tree$Select(_,_)             => false;
+      case Tree$Typed(_,_)              => false;
+      case _ => error("in TransMatch.isRegular phase: unknown node"+pat.getClass());
+    }
+
+    def nilVariables( pat:Tree ) = {
+      var res:scala.List[Symbol] = Nil;
+      def getNilVars1( ps:Array[Tree] ):scala.Unit = {
+        val z:Seq[Tree] = ps; z.elements.foreach( x => getNilVars( x ));
+      }
+      def getNilVars( p:Tree ):scala.Unit = p match {
+        case Tree$Alternative( _ )  => /* no bind allowed! */
+        case Tree$Bind( _, pat )     =>
+	  if( TreeInfo.isEmptySequence( pat ) )
+	    res = p.symbol() :: res;
+	  getNilVars(pat);
+	case Tree$Ident(_)          =>
+	case Tree$Sequence( trees ) => getNilVars1( trees )
+        case Tree$Apply( _,  args ) => getNilVars1( args )
+        case Tree$Literal(_)        =>
+        case Tree$Select(_,_)       =>
+        case Tree$Typed(_,_)        =>
+        case _ => error("in TransMatch.nilVariables: unknown node"+pat.getClass());
+      }
+      getNilVars( pat );
+      res
     }
 
+
   def  transform( root:Tree, cases:Array[Tree$CaseDef], restpe:Type ):Tree = {
     if( global.newMatch ) {
       val fm = new FullRegularTranslator( global );
@@ -93,18 +101,15 @@ class TransMatch( global:scalac_Global )
     var containsReg = false;
     var i = 0;
     while (i < cases.length) {
-      containsReg = TestRegTraverser.apply(cases( i )) || containsReg;
-      //containsReg = isRegular(cases(i).pat) || containsReg;
-      //TestRegTraverser.apply(cases( i ));
-      var nilvars:Set  = TestRegTraverser.getNilVariables();
-      if( !nilvars.isEmpty() ) {
-        val newBody = new Array[Tree]( nilvars.size() );
+      containsReg = isRegular(cases( i ).pat) || containsReg;
+
+      var nilvars = nilVariables(cases( i ).pat);
+      if( !nilvars.isEmpty ) {
+        val newBody = new Array[Tree]( nilvars.length );
         var j=0;
-        var it:Iterator = nilvars.iterator();
-        while( it.hasNext() ) {
-          val v:Symbol = it.next().asInstanceOf[ Symbol ];
-          val n = gen.mkNil(cases(i).pos);
-          newBody( j ) = gen.ValDef(v, n);
+        for( val v <- nilvars.elements ) {
+          val n = gen.mkNil( cases( i ).pos );
+          newBody( j ) = gen.ValDef( v, n );
           j = j + 1;
         }
         cases(i).body = gen.mkBlock( newBody, cases(i).body );
diff --git a/sources/scalac/transformer/matching/TestRegTraverser.java b/sources/scalac/transformer/matching/TestRegTraverser.java
deleted file mode 100644
index e5dae1fc6a..0000000000
--- a/sources/scalac/transformer/matching/TestRegTraverser.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*     ____ ____  ____ ____  ______                                     *\
-**    / __// __ \/ __// __ \/ ____/    SOcos COmpiles Scala             **
-**  __\_ \/ /_/ / /__/ /_/ /\_ \       (c) 2002, LAMP/EPFL              **
-** /_____/\____/\___/\____/____/                                        **
-**                                                                      **
-** $Id$
-\*                                                                      */
-
-package scalac.transformer.matching;
-
-import scalac.Global;
-import scalac.ast.*;
-import scalac.util.*;
-import scalac.symtab.*;
-import java.util.*;
-
-
-public class TestRegTraverser extends Traverser {
-    boolean result = false;
-    Set variables = new HashSet();
-    static Set nilVariables = new HashSet();
-
-    public void traverse(Tree tree) {
-        //System.out.println("traverse:"+tree);
-    	if (!result)
-	    switch (tree) {
-	    case Alternative(_):
-		result = true;
-		break;
-	    case Bind(Name n, Tree pat):
-                if( TreeInfo.isNameOfStarPattern( n ) ) {
-                    result = true;
-                }
-		if( TreeInfo.isEmptySequence( pat ) ) {
-		    // annoying special case: b@() [or b@(()|()) after normalization]
-		    //System.err.println("bindin empty "+tree.symbol());
-		    nilVariables.add(tree.symbol());
-                    result = true;
-		} else {
-		    variables.add(tree.symbol());
-		}
-		traverse(pat);
-		break;
-	    case Ident(_):
-		Symbol symbol = tree.symbol();
-		if ((symbol != Global.instance.definitions.PATTERN_WILDCARD) &&
-		    variables.contains(symbol))
-		    result = true;
-		break;
-	    case CaseDef(Tree pat, _, _):
-		traverse(pat);
-		break;
-
-	    case Sequence( Tree[] trees):
-                if( trees.length == 0 ) {
-                    result = true;
-                    break;
-                } else traverse( trees );
-		//result = true;
-		break;
-
-            case Apply(Tree fun, Tree[] args):
-                traverse(fun);
-                traverse(args);
-                if(( args.length == 1 )&&TreeInfo.isEmptySequence(args[ 0 ]))
-                    result = false;
-                return;
-            // Matthias PatternMatcher cannot handle this case
-                /*
-	    case Apply( Tree fn, Tree[] trees ):
-                if( trees.length == 1 )
-                    switch (trees[ 0 ]) {
-
-                    case Sequence( Tree[] trees2 ):
-                        if( trees2.length == 1 ) {
-                            switch (trees2[ 0 ]) {
-                            case Sequence( Tree[] trees3 ):
-                                result = true;
-                                break;
-                            }
-                            //System.out.println( fn );
-                            //System.out.println( tree.type() );
-                        } else super.traverse( tree );
-                        break;
-                    default:
-                        super.traverse( tree );
-                    }
-		break;
-                */
-	    default:
-		super.traverse( tree );
-	    }
-    }
-
-    public static boolean apply(Tree t) {
-        TestRegTraverser trt = new TestRegTraverser();
-        nilVariables.clear();
-        trt.traverse(t);
-        //System.out.println("TestRegTraverser says "+t+" -> "+trt.result);
-        return trt.result;
-    }
-
-    public static Set getNilVariables() {
-	return nilVariables;
-    }
-}