removed some type aliases form uniformity

12 files changed, 71 insertions, 49 deletions

diff --git a/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala b/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala
index 16e2fcd461..2d4c8ff74a 100644
--- a/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala
+++ b/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala
@@ -15,6 +15,28 @@ trait PatternMatchers requires (TransMatcher with PatternNodes) extends AnyRef w
   import typer.typed ;
   import symtab.Flags;
 
+  // -- begin new data structure for matcher
+
+  abstract class Node{}
+
+  class Test(var tpe: Type, var casted: Symbol) extends Node {
+    var thenp: Node  = _
+    var vbles = List[Symbol]();
+    def bindTo(v: Symbol): this.type = { vbles = v::vbles; this }
+    override def toString() = tpe.toString+"?"
+  }
+  class Load(var expr: Tree) extends Node {
+    def tpe = expr.tpe;
+    var thenp: PatNodeList = Snil
+  }
+  case class Return(b:Tree) extends Node {}
+
+  abstract class PatNodeList {};
+  case class Snoc(sx:PatNodeList, x:Test) extends PatNodeList;
+  case object Snil extends PatNodeList;
+
+    // -- end
+
  class PatternMatcher  {
 
 
diff --git a/src/library/scala/xml/NodeSeq.scala b/src/library/scala/xml/NodeSeq.scala
index 6a43e269ad..45d557b3fc 100644
--- a/src/library/scala/xml/NodeSeq.scala
+++ b/src/library/scala/xml/NodeSeq.scala
@@ -26,7 +26,7 @@ abstract class NodeSeq extends Seq[Node] {
   def theSeq: Seq[Node];
   def length = theSeq.length;
   def elements = theSeq.elements ;
-  def apply(i: int ): Node = theSeq.apply( i );
+  def apply(i: Int): Node = theSeq.apply( i );
 
   def apply(f: Node => Boolean): NodeSeq = filter(f);
 
diff --git a/src/library/scala/xml/Parsing.scala b/src/library/scala/xml/Parsing.scala
index 3dd849883a..c19fb022f5 100644
--- a/src/library/scala/xml/Parsing.scala
+++ b/src/library/scala/xml/Parsing.scala
@@ -70,7 +70,7 @@ object Parsing {
    *
    *  see  [5] of XML 1.0 specification
    */
-  def isName( s:String ):boolean = {
+  def isName( s:String ): Boolean = {
     if( s.length() > 0 ) {
       val z:Seq[Char] = s;
       val y           = z.elements;
@@ -90,11 +90,11 @@ object Parsing {
     case _ => false;
   }
 
-  def checkSysID( s:String ):boolean = {
+  def checkSysID(s: String): Boolean = {
     s.indexOf('"') == -1 || s.indexOf('\'') == -1
   }
 
-  def checkPubID( s:String ):boolean = {
+  def checkPubID(s: String): Boolean = {
     if( s.length() > 0 ) {
       val z:Seq[Char] = s;
       val y = z.elements;
diff --git a/src/library/scala/xml/dtd/ContentModelParser.scala b/src/library/scala/xml/dtd/ContentModelParser.scala
index ee7e04197e..712c0c24ff 100644
--- a/src/library/scala/xml/dtd/ContentModelParser.scala
+++ b/src/library/scala/xml/dtd/ContentModelParser.scala
@@ -21,7 +21,7 @@ object ContentModelParser extends Scanner { // a bit too permissive concerning #
   def parse(s:String): ContentModel = { initScanner( s ); contentspec }
 
   //                                              zzz   parser methods   zzz
-  def accept( tok:int ) = {
+  def accept(tok: Int) = {
     if( token != tok ) {
       if(( tok == STAR )&&( token == END ))                  // common mistake
         error("in DTDs, \n"+
@@ -34,7 +34,7 @@ object ContentModelParser extends Scanner { // a bit too permissive concerning #
   }
 
   // s [ '+' | '*' | '?' ]
-  def maybeSuffix(s:RegExp) = token match {
+  def maybeSuffix(s: RegExp) = token match {
     case STAR => nextToken; Star( s )
     case PLUS => nextToken; Sequ( s, Star( s ))
     case OPT  => nextToken; Alt( Eps, s )
diff --git a/src/library/scala/xml/dtd/Decl.scala b/src/library/scala/xml/dtd/Decl.scala
index c16d984792..271a0c0c98 100644
--- a/src/library/scala/xml/dtd/Decl.scala
+++ b/src/library/scala/xml/dtd/Decl.scala
@@ -172,7 +172,7 @@ case object IMPLIED extends DefaultDecl {
   final def toString(sb:StringBuffer) = sb.append("#IMPLIED");
 }
 
-case class DEFAULT(fixed:boolean, attValue:String) extends DefaultDecl {
+case class DEFAULT(fixed: Boolean, attValue:String) extends DefaultDecl {
   final override def toString(): String =
     toString(new StringBuffer()).toString();
 
diff --git a/src/library/scala/xml/dtd/Scanner.scala b/src/library/scala/xml/dtd/Scanner.scala
index ad6b8888c8..ef031a6fc7 100644
--- a/src/library/scala/xml/dtd/Scanner.scala
+++ b/src/library/scala/xml/dtd/Scanner.scala
@@ -66,7 +66,7 @@ class Scanner extends Tokens with parsing.TokenTests {
   }
   */
 
-  final def readToken:int =
+  final def readToken: Int =
     if(isSpace(c)) {
       while( isSpace(c) ) {
         c = it.next;
diff --git a/src/library/scala/xml/dtd/Tokens.scala b/src/library/scala/xml/dtd/Tokens.scala
index e1903e0bca..43185983a8 100644
--- a/src/library/scala/xml/dtd/Tokens.scala
+++ b/src/library/scala/xml/dtd/Tokens.scala
@@ -16,29 +16,29 @@ class Tokens {
 
   // Tokens
 
-  final val TOKEN_PCDATA = 0;
-  final val NAME         = 1;
-  final val LPAREN       = 3;
-  final val RPAREN       = 4;
-  final val COMMA        = 5;
-  final val STAR         = 6;
-  final val PLUS         = 7;
-  final val OPT          = 8;
-  final val CHOICE       = 9;
-  final val END          = 10;
-  final val S            = 13;
-
-  final def token2string( i:int ):String = i match {
-    case 0 => "#PCDATA";
-    case 1 => "NAME";
-    case 3 => "(";
-    case 4 => ")";
-    case 5 => ",";
-    case 6 => "*";
-    case 7 => "+";
-    case 8 => "?";
-    case 9 => "|";
-    case 10 => "END";
-    case 13 => " ";
+  final val TOKEN_PCDATA = 0
+  final val NAME         = 1
+  final val LPAREN       = 3
+  final val RPAREN       = 4
+  final val COMMA        = 5
+  final val STAR         = 6
+  final val PLUS         = 7
+  final val OPT          = 8
+  final val CHOICE       = 9
+  final val END          = 10
+  final val S            = 13
+
+  final def token2string(i: Int): String = i match {
+    case 0 => "#PCDATA"
+    case 1 => "NAME"
+    case 3 => "("
+    case 4 => ")"
+    case 5 => ","
+    case 6 => "*"
+    case 7 => "+"
+    case 8 => "?"
+    case 9 => "|"
+    case 10 => "END"
+    case 13 => " "
   }
 }
diff --git a/src/library/scala/xml/parsing/ConstructingHandler.scala b/src/library/scala/xml/parsing/ConstructingHandler.scala
index fa90409aa2..aaa1bf2ad9 100644
--- a/src/library/scala/xml/parsing/ConstructingHandler.scala
+++ b/src/library/scala/xml/parsing/ConstructingHandler.scala
@@ -15,7 +15,7 @@ package scala.xml.parsing;
 /** implementation of MarkupHandler that constructs nodes */
 abstract class ConstructingHandler extends MarkupHandler {
 
-  val preserveWS: boolean;
+  val preserveWS: Boolean;
 
   def elem(pos: int, pre: String, label: String, attrs: MetaData, pscope: NamespaceBinding, nodes: NodeSeq): NodeSeq =
     Elem(pre, label, attrs, pscope, nodes:_*);
diff --git a/src/library/scala/xml/parsing/FactoryAdapter.scala b/src/library/scala/xml/parsing/FactoryAdapter.scala
index 610f6febc1..ad24a8ab9a 100644
--- a/src/library/scala/xml/parsing/FactoryAdapter.scala
+++ b/src/library/scala/xml/parsing/FactoryAdapter.scala
@@ -46,14 +46,14 @@ abstract class FactoryAdapter extends DefaultHandler() {
   var scopeStack  = new Stack[NamespaceBinding];
 
   var curTag : String = null ;
-  var capture:boolean = false;
+  var capture: Boolean = false;
 
   // abstract methods
 
   /** Tests if an XML element contains text.
    * @return true if element named <code>localName</code> contains text.
    */
-  def nodeContainsText( localName:String ):boolean ; // abstract
+  def nodeContainsText(localName: String): Boolean ; // abstract
 
   /** creates an new non-text(tree) node.
    * @param elemName
@@ -84,23 +84,23 @@ abstract class FactoryAdapter extends DefaultHandler() {
 
         if (capture) {
           if( normalizeWhitespace ) { // normalizing whitespace is not compliant, but useful */
-	    var i:int = offset;
-            var ws:boolean = false;
+	    var i: Int = offset
+            var ws = false
 	    while (i < offset + length) {
               if ( Character.isWhitespace( ch(i) ) ) {
                 if (!ws) {
-                  buffer.append(' ');
-                  ws = true;
+                  buffer.append(' ')
+                  ws = true
                 }
               } else {
-                buffer.append(ch(i));
-                ws = false;
+                buffer.append(ch(i))
+                ws = false
               }
-	      i = i+1;
+	      i = i+1
             }
           } else { // compliant:report every character
 
-              buffer.append( ch, offset, length );
+              buffer.append( ch, offset, length )
 
           }
 	}
diff --git a/src/library/scala/xml/parsing/NoBindingFactoryAdapter.scala b/src/library/scala/xml/parsing/NoBindingFactoryAdapter.scala
index 0926ac2699..b3b17d6909 100644
--- a/src/library/scala/xml/parsing/NoBindingFactoryAdapter.scala
+++ b/src/library/scala/xml/parsing/NoBindingFactoryAdapter.scala
@@ -24,7 +24,7 @@ class NoBindingFactoryAdapter extends FactoryAdapter with NodeFactory[Elem] {
 
   /** returns true. Every XML node may contain text that the application needs
   **/
-  def nodeContainsText( label:java.lang.String ):boolean = true;
+  def nodeContainsText( label:java.lang.String ): Boolean = true;
 
 
   // methods for NodeFactory[Elem]
diff --git a/src/library/scala/xml/parsing/TokenTests.scala b/src/library/scala/xml/parsing/TokenTests.scala
index 65d07e170f..1b5ec0b4ec 100644
--- a/src/library/scala/xml/parsing/TokenTests.scala
+++ b/src/library/scala/xml/parsing/TokenTests.scala
@@ -18,7 +18,7 @@ package scala.xml.parsing;
 trait TokenTests {
 
   /** (#x20 | #x9 | #xD | #xA) */
-  final def isSpace( ch:Char ):Boolean = ch match {
+  final def isSpace( ch:Char ): Boolean = ch match {
     case '\u0009' | '\u000A' | '\u000D' | '\u0020' => true
     case _                                         => false;
   }
@@ -70,7 +70,7 @@ trait TokenTests {
    *
    *  see  [5] of XML 1.0 specification
    */
-  def isName(s: String): boolean = {
+  def isName(s: String): Boolean = {
     if( s.length() > 0 ) {
       val z:Seq[Char] = s;
       val y           = z.elements;
@@ -81,7 +81,7 @@ trait TokenTests {
     } else false;
   }
 
-  def isPubIDChar(ch: Char): boolean = {
+  def isPubIDChar(ch: Char): Boolean = {
     //Console.println("char: '" + ch + "'");
     ch match {
       case '\u0020' | '\u000D' | '\u000A' => true;
@@ -125,7 +125,7 @@ trait TokenTests {
       return false;
   } // isValidIANAEncoding(String): Boolean
 
-  def checkSysID( s:String ):boolean = {
+  def checkSysID( s:String ): Boolean = {
     s.indexOf('"') == -1 || s.indexOf('\'') == -1
   }
 
diff --git a/src/library/scala/xml/parsing/ValidatingMarkupHandler.scala b/src/library/scala/xml/parsing/ValidatingMarkupHandler.scala
index bce3720fb1..8c1d0a5767 100644
--- a/src/library/scala/xml/parsing/ValidatingMarkupHandler.scala
+++ b/src/library/scala/xml/parsing/ValidatingMarkupHandler.scala
@@ -29,7 +29,7 @@ abstract class ValidatingMarkupHandler extends MarkupHandler with Logged {
   override def log(msg:String) = {};
 
   /*
-  override def checkChildren(pos:int, pre: String, label:String,ns:NodeSeq): Unit = {
+  override def checkChildren(pos: Int, pre: String, label:String,ns:NodeSeq): Unit = {
     Console.println("checkChildren()");
     val decl = lookupElemDecl(label);
     // @todo: nice error message