disallowing forms of binding that lead to bug

2 files changed, 45 insertions, 10 deletions

diff --git a/sources/scalac/ast/TreeInfo.java b/sources/scalac/ast/TreeInfo.java
index 81c97a7e73..2aa95f401c 100644
--- a/sources/scalac/ast/TreeInfo.java
+++ b/sources/scalac/ast/TreeInfo.java
@@ -241,4 +241,29 @@ public class TreeInfo {
 	    return false;
 	}
     }
+      /** this test should correspond to the one used in TransMatch phase */
+      public static boolean isRegularPattern( Tree tree ) {
+	    switch (tree) {
+	    case Alternative(_):
+                  return true;
+	    case Bind(_, Tree pat):
+                  return isRegularPattern( pat );
+	    case Ident(_):
+                  return false;
+	    case CaseDef(Tree pat, _, _):
+                  isRegularPattern(pat);
+                  break;
+	    case Sequence( Tree[] trees):
+                  return true;
+            case Apply( _, Tree[] trees ):
+                  for( int i = 0; i < trees.length; i++ )
+                        if( isRegularPattern( trees[i] ) )
+                              return true;
+            case Literal( _ ):
+                  return false;
+
+	    }
+            return false;
+      }
+
 }
diff --git a/sources/scalac/ast/parser/PatternNormalizer.java b/sources/scalac/ast/parser/PatternNormalizer.java
index f2a35829df..adf8a98b9d 100644
--- a/sources/scalac/ast/parser/PatternNormalizer.java
+++ b/sources/scalac/ast/parser/PatternNormalizer.java
@@ -43,6 +43,7 @@ public class PatternNormalizer {
     ///////// CHECKING patterns for well-formedness ///////////////////////////////
     //
 
+    int seqDepth;
 
     /** checks whether TO DO TO DO TO DO
      *  - @-recursion occurs only at the end just below a sequence
@@ -57,10 +58,16 @@ public class PatternNormalizer {
 	    return true;
 
 	case Apply( _, Tree[] args ):
-	    return check1( args, inAlt );
+              seqDepth++;
+              boolean res = check1( args, inAlt );
+              seqDepth--;
+              return res;
 
-	case Sequence( Tree[] trees ):
-	    return check1( trees, inAlt );
+	case Sequence( Tree[] trees ): // this is a hack to disallow deep binding
+              seqDepth++;
+              boolean res = check1( trees, inAlt );
+              seqDepth--;
+              return res;
 
 	case Alternative( Tree[] trees ):
 	    return check1( trees, true );
@@ -73,6 +80,12 @@ public class PatternNormalizer {
 			      "variable binding not allowed under alternative");
 		return false;
 	    }
+            if(( seqDepth > 2 )
+               &&( var.toString().lastIndexOf("$") == -1)) {
+		unit.error( t.pos,
+			      "sorry, deep binding not implemented");
+		return false;
+            }
 	    this.boundVars.put( var /*t.symbol()*/, Boolean.FALSE );
 	    /*
               boolean result = check( tree, inSeq );
@@ -110,13 +123,6 @@ public class PatternNormalizer {
 	case Select( _, _ ):
 	    return true;
 
-            /*
-	case Empty: // may appear just as Sequence Sequence
-	    if ( !inSeq )
-		unit.error( t.pos,
-			    "empty subsequence without surrounding '['']'");
-	    return inSeq;
-	    */
 	default:
 	    unit.error( t.pos, "whut'z dis ?"+t.toString()); // never happens
 	}
@@ -141,6 +147,10 @@ public class PatternNormalizer {
        */
       public boolean check( Tree pat ) {
             this.boundVars = new HashMap();
+            if( TreeInfo.isRegularPattern( pat ) )
+                  seqDepth = 0;
+            else
+                  seqDepth = -32;  // don't care about sequences. see above
             return check1( pat, false );
     }