removed type aliases, update svn:keywords

20 files changed, 196 insertions, 193 deletions

diff --git a/src/actors/scala/actors/Actor.scala b/src/actors/scala/actors/Actor.scala
index 3ba4da09a2..55eb9ce314 100644
--- a/src/actors/scala/actors/Actor.scala
+++ b/src/actors/scala/actors/Actor.scala
@@ -119,7 +119,7 @@ object Actor {
    * @param  f    a partial function specifying patterns and actions
    * @return      the result of processing the received message
    */
-  def receiveWithin[R](msec: long)(f: PartialFunction[Any, R]): R =
+  def receiveWithin[R](msec: Long)(f: PartialFunction[Any, R]): R =
     self.receiveWithin(msec)(f)
 
   /**
diff --git a/src/actors/scala/actors/Scheduler.scala b/src/actors/scala/actors/Scheduler.scala
index 64478262ea..e92e76a803 100644
--- a/src/actors/scala/actors/Scheduler.scala
+++ b/src/actors/scala/actors/Scheduler.scala
@@ -84,7 +84,7 @@ object Scheduler {
   def shutdown() = sched.shutdown()
 
   def onLockup(handler: () => Unit) = sched.onLockup(handler)
-  def onLockup(millis: int)(handler: () => Unit) = sched.onLockup(millis)(handler)
+  def onLockup(millis: Int)(handler: () => Unit) = sched.onLockup(millis)(handler)
   def printActorDump = sched.printActorDump
 }
 
@@ -112,7 +112,7 @@ trait IScheduler {
   def shutdown(): Unit
 
   def onLockup(handler: () => Unit): Unit
-  def onLockup(millis: int)(handler: () => Unit): Unit
+  def onLockup(millis: Int)(handler: () => Unit): Unit
   def printActorDump: Unit
 
   val QUIT_TASK = new Reaction(null) {
diff --git a/src/actors/scala/actors/remote/FreshNameCreator.scala b/src/actors/scala/actors/remote/FreshNameCreator.scala
index 1ca6c16089..8c56cbc6ce 100644
--- a/src/actors/scala/actors/remote/FreshNameCreator.scala
+++ b/src/actors/scala/actors/remote/FreshNameCreator.scala
@@ -13,7 +13,7 @@ package scala.actors.remote
 object FreshNameCreator {
 
   protected var counter = 0
-  protected val counters = new scala.collection.mutable.HashMap[String,int]
+  protected val counters = new scala.collection.mutable.HashMap[String, Int]
 
   /**
    * Create a fresh name with the given prefix. It is guaranteed
diff --git a/src/actors/scala/actors/remote/Serializer.scala b/src/actors/scala/actors/remote/Serializer.scala
index 6e71171997..18ef3eeadd 100644
--- a/src/actors/scala/actors/remote/Serializer.scala
+++ b/src/actors/scala/actors/remote/Serializer.scala
@@ -17,14 +17,14 @@ import java.lang.ClassNotFoundException
 import java.io.{DataInputStream, DataOutputStream, EOFException, IOException}
 
 abstract class Serializer(val service: Service) {
-  def serialize(o: AnyRef): Array[byte]
-  def deserialize(a: Array[byte]): AnyRef
+  def serialize(o: AnyRef): Array[Byte]
+  def deserialize(a: Array[Byte]): AnyRef
 
   @throws(classOf[IOException])
-  def readBytes(inputStream: DataInputStream): Array[byte] = {
+  def readBytes(inputStream: DataInputStream): Array[Byte] = {
     try {
       val length = inputStream.readInt()
-      val bytes = new Array[byte](length)
+      val bytes = new Array[Byte](length)
       inputStream.readFully(bytes, 0, length)
       return bytes
     }
@@ -41,7 +41,7 @@ abstract class Serializer(val service: Service) {
   }
 
   @throws(classOf[IOException])
-  def writeBytes(outputStream: DataOutputStream, bytes: Array[byte]) {
+  def writeBytes(outputStream: DataOutputStream, bytes: Array[Byte]) {
     val length = bytes.length;
     // original length
     outputStream.writeInt(length)
diff --git a/src/compiler/scala/tools/nsc/ast/parser/NewScanners.scala b/src/compiler/scala/tools/nsc/ast/parser/NewScanners.scala
index cabb1a075c..f07eddcdfe 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/NewScanners.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/NewScanners.scala
@@ -1,4 +1,11 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2007 LAMP/EPFL
+ * @author  Sean McDirmid
+ */
+// $Id$
+
 package scala.tools.nsc.ast.parser
+
 import scala.tools.nsc.util.SourceFile._
 import scala.tools.nsc.util._
 
@@ -735,7 +742,7 @@ trait NewScanners {
   }
 
   object ScannerConfiguration {
-    private var key: Array[byte] = _
+    private var key: Array[Byte] = _
     private var maxKey = 0
     private var tokenName = new Array[global.Name](128);
     {
@@ -806,18 +813,18 @@ trait NewScanners {
       enterKeyword(nme.ATkw, AT)
 
       // Build keyword array
-      key = new Array[byte](maxKey + 1)
+      key = new Array[Byte](maxKey + 1)
       for (i <- 0 to maxKey)
         key(i) = IDENTIFIER
       for (j <- 0 until tokenCount)
         if (tokenName(j) ne null)
-          key(tokenName(j).start) = j.asInstanceOf[byte]
+          key(tokenName(j).start) = j.asInstanceOf[Byte]
 
     }
 //Token representation -----------------------------------------------------
 
   /** Convert name to token */
-  def name2token(name: global.Name): int =
+  def name2token(name: global.Name): Int =
     if (name.start <= maxKey) key(name.start) else IDENTIFIER
 
   def isKeyword(code : Int) = code match {
@@ -825,7 +832,7 @@ trait NewScanners {
   case _ => false
   }
   /** Returns the string representation of given token. */
-  def token2string(token: int): String = token match {
+  def token2string(token: Int): String = token match {
     case IDENTIFIER | BACKQUOTED_IDENT => "identifier"
     case CHARLIT => "character literal"
     case INTLIT => "integer literal"
diff --git a/src/compiler/scala/tools/nsc/matching/TransMatcher.scala b/src/compiler/scala/tools/nsc/matching/TransMatcher.scala
index 2a244f028d..cc5f3b5505 100644
--- a/src/compiler/scala/tools/nsc/matching/TransMatcher.scala
+++ b/src/compiler/scala/tools/nsc/matching/TransMatcher.scala
@@ -297,11 +297,11 @@ trait TransMatcher { self: transform.ExplicitOuter with PatternNodes with Parall
   }
 
   object resetTrav extends Traverser {
-    override def traverse(x:Tree): unit = x match {
-      case vd @ ValDef(_,_,_,_)=>
-        if(vd.symbol.hasFlag(symtab.Flags.SYNTHETIC))  {
-          vd.symbol.resetFlag(symtab.Flags.TRANS_FLAG)
-          vd.symbol.resetFlag(symtab.Flags.MUTABLE)
+    override def traverse(x: Tree): Unit = x match {
+      case vd @ ValDef(_, _, _, _) =>
+        if (vd.symbol hasFlag symtab.Flags.SYNTHETIC) {
+          vd.symbol resetFlag symtab.Flags.TRANS_FLAG
+          vd.symbol resetFlag symtab.Flags.MUTABLE
         }
       case _ =>
         super.traverse(x)
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/PickleBuffer.scala b/src/compiler/scala/tools/nsc/symtab/classfile/PickleBuffer.scala
index 986fc11ffd..f858d52734 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/PickleBuffer.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/PickleBuffer.scala
@@ -78,7 +78,7 @@ class PickleBuffer(data: Array[Byte], from: Int, to: Int) {
     val y = x >> 8
     val z = x & 0xff
     if (-y != (z >> 7)) writeLong(y)
-    writeByte(z.asInstanceOf[int])
+    writeByte(z.asInstanceOf[Int])
   }
 
   // -- Basic input routines --------------------------------------------
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
index a60333f005..c969dc2f52 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
@@ -52,7 +52,7 @@ abstract class Pickler extends SubComponent {
               var i = 0
               while (i < pickle.writeIndex) {
                 unit.pickleHash += pickle.bytes(i).toLong // toLong needed to work around bug
-                i = i + 1
+                i += 1
               }
             }
           case _ =>
@@ -67,7 +67,7 @@ abstract class Pickler extends SubComponent {
     import scala.collection.jcl.LinkedHashMap
     private var entries = new Array[AnyRef](256)
     private var ep = 0
-    private val index = new LinkedHashMap[AnyRef, int]
+    private val index = new LinkedHashMap[AnyRef, Int]
 
     /** Is root in symbol.owner*?
      *
@@ -336,7 +336,7 @@ abstract class Pickler extends SubComponent {
       var posOffset = 0
       writeRef(sym.name)
       writeRef(sym.owner)
-      writeNat((sym.flags & PickledFlags).asInstanceOf[int])
+      writeNat((sym.flags & PickledFlags).asInstanceOf[Int])
       if (sym.privateWithin != NoSymbol) writeRef(sym.privateWithin)
       writeRef(sym.info)
       posOffset
diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index 2bff857011..a2575e59ad 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -492,11 +492,11 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
      *  @param pt   ...
      *  @return     the adapted tree
      */
-    override protected def adapt(tree: Tree, mode: int, pt: Type): Tree =
+    override protected def adapt(tree: Tree, mode: Int, pt: Type): Tree =
       adaptToType(tree, pt)
 
     /** A replacement for the standard typer's `typed1' method */
-    override protected def typed1(tree: Tree, mode: int, pt: Type): Tree = {
+    override protected def typed1(tree: Tree, mode: Int, pt: Type): Tree = {
       var tree1 = try {
         super.typed1(adaptMember(tree), mode, pt)
       } catch {
diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
index 113c5f1296..cd48899c17 100644
--- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
@@ -22,7 +22,7 @@ abstract class ExplicitOuter extends InfoTransform with TransMatcher with Patter
   import posAssigner.atPos
 
   /** The following flags may be set by this phase: */
-  override def phaseNewFlags: long = notPRIVATE | notPROTECTED | lateFINAL
+  override def phaseNewFlags: Long = notPRIVATE | notPROTECTED | lateFINAL
 
   /** the name of the phase: */
   val phaseName: String = "explicitouter"
diff --git a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
index 1ec4da1a54..defcc6ce2e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
@@ -1,5 +1,5 @@
 /* NSC -- new Scala compiler
- * Copyright 2005-2006 LAMP/EPFL
+ * Copyright 2005-2007 LAMP/EPFL
  * @author  Martin Odersky
  */
 // $Id$
@@ -18,15 +18,16 @@ trait Analyzer extends AnyRef
             with SyntheticMethods
             with Unapplies {
 
-  val global : Global;
-  import global._;
+  val global : Global
+  import global._
 
   object namerFactory extends SubComponent {
     val global: Analyzer.this.global.type = Analyzer.this.global
     val phaseName = "namer"
     def newPhase(_prev: Phase): StdPhase = new StdPhase(_prev) {
-      def apply(unit: CompilationUnit): unit =
+      def apply(unit: CompilationUnit) {
         newNamer(rootContext(unit)).enterSym(unit.body)
+      }
     }
   }
 
@@ -35,8 +36,9 @@ trait Analyzer extends AnyRef
     val phaseName = "typer"
     def newPhase(_prev: Phase): StdPhase = new StdPhase(_prev) {
       resetTyper
-      def apply(unit: CompilationUnit): unit =
+      def apply(unit: CompilationUnit) {
         unit.body = newTyper(rootContext(unit)).typed(unit.body)
+      }
     }
   }
 }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index ee1637c65a..f0311dd885 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -55,7 +55,7 @@ trait Contexts { self: Analyzer =>
   def rootContext(unit: CompilationUnit): Context =
     rootContext(unit, EmptyTree, false)
 
-  def rootContext(unit: CompilationUnit, tree: Tree, erasedTypes: boolean): Context = {
+  def rootContext(unit: CompilationUnit, tree: Tree, erasedTypes: Boolean): Context = {
     import definitions._
     var sc = startContext
     def addImport(pkg: Symbol) {
@@ -423,7 +423,7 @@ trait Contexts { self: Analyzer =>
      *  @param superAccess ...
      *  @return            ...
      */
-    def isAccessible(sym: Symbol, pre: Type, superAccess: boolean): boolean = {
+    def isAccessible(sym: Symbol, pre: Type, superAccess: Boolean): Boolean = {
 
       /** Are we inside definition of `owner'? */
       def accessWithin(owner: Symbol): Boolean = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 869d16aac5..695cb60f5e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -473,7 +473,7 @@ abstract class RefChecks extends InfoTransform {
     }
 
     private var currentLevel: LevelInfo = null
-    private val symIndex = new HashMap[Symbol, int]
+    private val symIndex = new HashMap[Symbol, Int]
 
     private def pushLevel() {
       currentLevel = new LevelInfo(currentLevel)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index f3a54e716a..ef07b183f3 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -482,7 +482,7 @@ trait Typers { self: Analyzer =>
      *  <!--(3)--><li>Turn tree type into stable type if possible and required by context.</li>
      *  </ol>
      */
-    private def stabilize(tree: Tree, pre: Type, mode: int, pt: Type): Tree = {
+    private def stabilize(tree: Tree, pre: Type, mode: Int, pt: Type): Tree = {
       def isDeprecated(sym: Symbol) = sym.isDeprecated
       if (tree.symbol.hasFlag(OVERLOADED) && (mode & FUNmode) == 0)
         inferExprAlternative(tree, pt)
@@ -607,7 +607,7 @@ trait Typers { self: Analyzer =>
      *  (13) When in mode EXPRmode, apply a view
      *  If all this fails, error
      */
-    protected def adapt(tree: Tree, mode: int, pt: Type): Tree = tree.tpe match {
+    protected def adapt(tree: Tree, mode: Int, pt: Type): Tree = tree.tpe match {
       case ct @ ConstantType(value) if ((mode & TYPEmode) == 0 && (ct <:< pt) && !inIDE) => // (0)
         copy.Literal(tree, value)
       case OverloadedType(pre, alts) if ((mode & FUNmode) == 0) => // (1)
@@ -799,7 +799,7 @@ trait Typers { self: Analyzer =>
      *  @param pt   ...
      *  @return     ...
      */
-    def instantiate(tree: Tree, mode: int, pt: Type): Tree = {
+    def instantiate(tree: Tree, mode: Int, pt: Type): Tree = {
       val tparams = context.undetparams
       context.undetparams = List()
       inferExprInstance(tree, tparams, pt)
@@ -2017,7 +2017,7 @@ trait Typers { self: Analyzer =>
      *  @param pt   ...
      *  @return     ...
      */
-    protected def typed1(tree: Tree, mode: int, pt: Type): Tree = {
+    protected def typed1(tree: Tree, mode: Int, pt: Type): Tree = {
       //Console.println("typed1("+tree.getClass()+","+Integer.toHexString(mode)+","+pt+")")
       def ptOrLub(tps: List[Type]) = if (isFullyDefined(pt)) pt else lub(tps map (_.deconst))
 
diff --git a/src/compiler/scala/tools/nsc/util/CharArrayReader.scala b/src/compiler/scala/tools/nsc/util/CharArrayReader.scala
index 4f99ecc221..dd971bc981 100644
--- a/src/compiler/scala/tools/nsc/util/CharArrayReader.scala
+++ b/src/compiler/scala/tools/nsc/util/CharArrayReader.scala
@@ -9,9 +9,9 @@ package scala.tools.nsc.util
 import scala.tools.nsc.util.SourceFile.{LF, FF, CR, SU}
 
 class CharArrayReader(buf: RandomAccessSeq[Char], start: Int, /* startline: int, startcol: int, */
-                      decodeUni: Boolean, error: String => unit) extends Iterator[Char] {
+                      decodeUni: Boolean, error: String => Unit) extends Iterator[Char] {
 
-  def this(buf: RandomAccessSeq[Char], decodeUni: Boolean, error: String => unit) =
+  def this(buf: RandomAccessSeq[Char], decodeUni: Boolean, error: String => Unit) =
     this(buf, 0, /* 1, 1, */ decodeUni, error)
 
   /** layout constant
diff --git a/src/compiler/scala/tools/nsc/util/NewCharArrayReader.scala b/src/compiler/scala/tools/nsc/util/NewCharArrayReader.scala
index 3f889587ed..f667063b5a 100644
--- a/src/compiler/scala/tools/nsc/util/NewCharArrayReader.scala
+++ b/src/compiler/scala/tools/nsc/util/NewCharArrayReader.scala
@@ -9,7 +9,7 @@ package scala.tools.nsc.util
 import scala.tools.nsc.util.SourceFile.{LF, FF, CR, SU}
 
 class NewCharArrayReader(val buf: RandomAccessSeq[Char], // should not change
-                       decodeUni: Boolean, error: (Int,String) => unit) extends Iterator[Char] {
+                       decodeUni: Boolean, error: (Int,String) => Unit) extends Iterator[Char] {
   private var idx : Int = 0
   private var isUnicode0 = false
   def isUnicode = isUnicode0
diff --git a/src/library/scala/xml/include/sax/EncodingHeuristics.scala b/src/library/scala/xml/include/sax/EncodingHeuristics.scala
index 976d475975..adab470106 100644
--- a/src/library/scala/xml/include/sax/EncodingHeuristics.scala
+++ b/src/library/scala/xml/include/sax/EncodingHeuristics.scala
@@ -43,14 +43,14 @@ object EncodingHeuristics {
     //System.err.println("EncodingHeuristics::readEncodingFromStream");
     // This may fail if there are a lot of space characters before the end
     // of the encoding declaration
-    in.mark(1024);
-    var ret: String = null;
+    in.mark(1024)
+    var ret: String = null
     try {
       // lots of things can go wrong here. If any do, I just return null
       // so that we'll fall back on the encoding declaration or the
       // UTF-8 default
-      val byte1 = in.read();
-      val byte2 = in.read();
+      val byte1 = in.read()
+      val byte2 = in.read()
       if (byte1 == 0xFE && byte2 == 0xFF) {
         // don't reset because the byte order mark should not be included????
         ret =  "UnicodeBig"; // name for big-endian????
@@ -58,7 +58,7 @@ object EncodingHeuristics {
       else if (byte1 == 0xFF && byte2 == 0xFE) {
         // don't reset because the byte order mark should not be included????
         // will the reader throw away the byte order mark or will it return it????
-        ret =  "UnicodeLittle";
+        ret =  "UnicodeLittle"
       }
 
       /* In accordance with the Character Model [Character Model],
@@ -67,7 +67,7 @@ object EncodingHeuristics {
        selected range is non-normalized. When transcoding characters
        to a Unicode encoding from a legacy encoding, a normalizing transcoder must be used. */
 
-      val byte3 = in.read();
+      val byte3 = in.read()
       // check for UTF-8 byte order mark
       if (byte1 == 0xEF && byte2 == 0xBB && byte3 == 0xBF) {
         // don't reset because the byte order mark should not be included????
@@ -89,29 +89,29 @@ object EncodingHeuristics {
       // less than sign or white space
       // Let's look for less-than signs first
       if (byte1 == 0x00 && byte2 == 0x00 && byte3 == 0x00 && byte4 == '<') {
-        in.reset();
-        ret =  "UCS-4"; // right name for big-endian UCS-4 in Java 1.4????
+        in.reset()
+        ret =  "UCS-4"  // right name for big-endian UCS-4 in Java 1.4????
       }
       else if (byte1 == '<' && byte2 == 0x00 && byte3 == 0x00 && byte4 == 0x00) {
-        in.reset();
-        ret =  "UCS-4"; // right name for little-endian UCS-4 in Java 1.4????
+        in.reset()
+        ret =  "UCS-4"  // right name for little-endian UCS-4 in Java 1.4????
       }
       else if (byte1 == 0x00 && byte2 == '<' && byte3 == 0x00 && byte4 == '?') {
-        in.reset();
-        ret =  "UnicodeBigUnmarked";
+        in.reset()
+        ret =  "UnicodeBigUnmarked"
       }
       else if (byte1 == '<' && byte2 == 0x00 && byte3 == '?' && byte4 == 0x00) {
-        in.reset();
-        ret =  "UnicodeLittleUnmarked";
+        in.reset()
+        ret =  "UnicodeLittleUnmarked"
       }
       else if (byte1 == '<' && byte2 == '?' && byte3 == 'x' && byte4 == 'm') {
         // ASCII compatible, must read encoding declaration
         // 1024 bytes will be far enough to read most XML declarations
-        val data = new Array[byte](1024);
-        data(0) = byte1.asInstanceOf[byte];
-        data(1) = byte2.asInstanceOf[byte];;
-        data(2) = byte3.asInstanceOf[byte];;
-        data(3) = byte4.asInstanceOf[byte];;
+        val data = new Array[Byte](1024)
+        data(0) = byte1.asInstanceOf[Byte]
+        data(1) = byte2.asInstanceOf[Byte]
+        data(2) = byte3.asInstanceOf[Byte]
+        data(3) = byte4.asInstanceOf[Byte]
         val length = in.read(data, 4, 1020) + 4;
         // Use Latin-1 (ISO-8859-1) because it's ASCII compatible and
         // all byte sequences are legal Latin-1 sequences so I don't have
@@ -122,37 +122,36 @@ object EncodingHeuristics {
         // we just fall into the catch bloclk and return null
         // since this can't be well-formed XML
         var position = declaration.indexOf("encoding") + 8;
-        var c: char = '\0'; // bogus init value
+        var c: Char = '\0'  // bogus init value
         // get rid of white space before equals sign
         do {
-          c = declaration.charAt(position);
-          position = position + 1;
+          c = declaration.charAt(position)
+          position += 1
         } while (c == ' ' || c == '\t' || c == '\r' || c == '\n') ;
         if (c != '=') { // malformed
-          in.reset();
-          ret =  "UTF-8";
+          in.reset()
+          ret =  "UTF-8"
         }
         // get rid of white space after equals sign
         do {
-          c = declaration.charAt(position);
-          position = position + 1;
+          c = declaration.charAt(position)
+          position += 1
         } while (c == ' ' || c == '\t' || c == '\r' || c == '\n') ;
-        var delimiter: char  = c;
+        var delimiter: Char = c
         if (delimiter != '\'' && delimiter != '"') { // malformed
-          in.reset();
-          ret =  "UTF-8";
+          in.reset()
+          ret =  "UTF-8"
         }
         // now positioned to read encoding name
-        val encodingName = new StringBuffer();
+        val encodingName = new StringBuffer()
         do {
-          c = declaration.charAt(position);
-          position = position + 1;
-          encodingName.append(c);
-        } while(c != delimiter);
-        encodingName.setLength(encodingName.length() - 1); // rm delim
-        in.reset();
-        ret =  encodingName.toString();
-
+          c = declaration.charAt(position)
+          position += 1
+          encodingName.append(c)
+        } while(c != delimiter)
+        encodingName.setLength(encodingName.length() - 1)  // rm delim
+        in.reset()
+        ret =  encodingName.toString()
       }
         else if (byte1 == 0x4C && byte2 == 0x6F && byte3 == 0xA7 && byte4 == 0x94) {
           // EBCDIC compatible, must read encoding declaration
@@ -160,18 +159,19 @@ object EncodingHeuristics {
         }
 
     } catch {
-      case e: Exception => in.reset();
-      ret =  "UTF-8";
+      case e: Exception =>
+        in.reset()
+        ret = "UTF-8"
     }
 
     // no XML or text declaration present
     //System.err.println("exit EncodingHeuristics::readEncodingFromStream");
 
     if (ret != null)
-      return ret
+      ret
     else {
-      in.reset();
-      return "UTF-8";
+      in.reset()
+      "UTF-8"
     }
   }
 }
diff --git a/src/library/scala/xml/include/sax/Main.scala b/src/library/scala/xml/include/sax/Main.scala
index 795ca0fbfa..1ed32fee36 100644
--- a/src/library/scala/xml/include/sax/Main.scala
+++ b/src/library/scala/xml/include/sax/Main.scala
@@ -51,14 +51,14 @@ object Main {
       }
       catch {
         case e:SAXException =>
-          System.err.println(e);
+          System.err.println(e)
           err = true
       }
-      if(err) return;
+      if (err) return
 
-      if (args.length == 0) return;
-      var resolver: EntityResolver = null;
-      var arg: int = 0;
+      if (args.length == 0) return
+      var resolver: EntityResolver = null
+      var arg: Int = 0
       if (args(0).equals("-r")) {
         try {
           resolver = Class.forName(args(1)).newInstance().asInstanceOf[EntityResolver];
@@ -66,30 +66,30 @@ object Main {
         }
         catch {
           case ex:Exception =>
-            System.err.println("Could not load requested EntityResolver");
-          err = true;
+            System.err.println("Could not load requested EntityResolver")
+            err = true
         }
-        arg = 2;
+        arg = 2
       }
-      if (err) return;
+      if (err) return
 
       while (arg < args.length) {
         try {
           val includer = new XIncludeFilter();
-          includer.setParent(parser);
-          val s = new XIncluder(System.out, "UTF-8");
-          includer.setContentHandler(s);
-          if (resolver != null) includer.setEntityResolver(resolver);
+          includer.setParent(parser)
+          val s = new XIncluder(System.out, "UTF-8")
+          includer.setContentHandler(s)
+          if (resolver != null) includer.setEntityResolver(resolver)
           try {
             includer.setProperty(
               "http://xml.org/sax/properties/lexical-handler",
-              s);
-            s.setFilter(includer);
+              s)
+            s.setFilter(includer)
           }
           catch {
             case e:SAXException => // Will not support comments
           }
-          includer.parse(args(arg));
+          includer.parse(args(arg))
         }
         catch {
           case e:SAXParseException =>
diff --git a/src/library/scala/xml/include/sax/XIncludeFilter.scala b/src/library/scala/xml/include/sax/XIncludeFilter.scala
index 23033c239c..7a0bcfe1fc 100644
--- a/src/library/scala/xml/include/sax/XIncludeFilter.scala
+++ b/src/library/scala/xml/include/sax/XIncludeFilter.scala
@@ -113,17 +113,17 @@ class XIncludeFilter extends XMLFilterImpl {
     // what if this isn't called????
     // do I need to check this in startDocument() and push something
     // there????
-  override def setDocumentLocator(locator: Locator): Unit = {
-    locators.push(locator);
-    val base = locator.getSystemId();
+  override def setDocumentLocator(locator: Locator) {
+    locators.push(locator)
+    val base = locator.getSystemId()
     try {
-      bases.push(new URL(base));
+      bases.push(new URL(base))
     }
     catch {
       case e:MalformedURLException =>
-        throw new UnsupportedOperationException("Unrecognized SYSTEM ID: " + base);
+        throw new UnsupportedOperationException("Unrecognized SYSTEM ID: " + base)
     }
-    super.setDocumentLocator(locator);
+    super.setDocumentLocator(locator)
   }
 
 
@@ -142,7 +142,7 @@ class XIncludeFilter extends XMLFilterImpl {
     *
     * @return boolean
     */
-  def insideIncludeElement(): boolean = level != 0
+  def insideIncludeElement(): Boolean = level != 0
 
   override def startElement(uri: String, localName: String, qName: String, atts1: Attributes) {
     var atts = atts1
@@ -150,31 +150,31 @@ class XIncludeFilter extends XMLFilterImpl {
 
       // Adjust bases stack by pushing either the new
       // value of xml:base or the base of the parent
-      val base = atts.getValue(NamespaceSupport.XMLNS, "base");
-      val parentBase = bases.peek().asInstanceOf[URL];
-      var currentBase = parentBase;
+      val base = atts.getValue(NamespaceSupport.XMLNS, "base")
+      val parentBase = bases.peek().asInstanceOf[URL]
+      var currentBase = parentBase
       if (base != null) {
         try {
-          currentBase = new URL(parentBase, base);
+          currentBase = new URL(parentBase, base)
         }
         catch {
           case e: MalformedURLException =>
             throw new SAXException("Malformed base URL: "
-                                   + currentBase, e);
+                                   + currentBase, e)
         }
       }
       bases.push(currentBase);
 
       if (uri.equals(XINCLUDE_NAMESPACE) && localName.equals("include")) {
         // include external document
-        val href = atts.getValue("href");
+        val href = atts.getValue("href")
         // Verify that there is an href attribute
         if (href==null) {
-          throw new SAXException("Missing href attribute");
+          throw new SAXException("Missing href attribute")
         }
 
-        var parse = atts.getValue("parse");
-        if (parse == null) parse = "xml";
+        var parse = atts.getValue("parse")
+        if (parse == null) parse = "xml"
 
         if (parse.equals("text")) {
           val encoding = atts.getValue("encoding");
@@ -188,99 +188,94 @@ class XIncludeFilter extends XMLFilterImpl {
           throw new SAXException(
             "Illegal value for parse attribute: " + parse);
         }
-        level = level + 1;
+        level += 1
       }
-        else {
-          if (atRoot) {
-            // add xml:base attribute if necessary
-            val attsImpl = new AttributesImpl(atts);
-            attsImpl.addAttribute(NamespaceSupport.XMLNS, "base",
-                                  "xml:base", "CDATA", currentBase.toExternalForm());
-            atts = attsImpl;
-            atRoot = false;
-          }
-          super.startElement(uri, localName, qName, atts);
+      else {
+        if (atRoot) {
+          // add xml:base attribute if necessary
+          val attsImpl = new AttributesImpl(atts)
+          attsImpl.addAttribute(NamespaceSupport.XMLNS, "base",
+                                "xml:base", "CDATA", currentBase.toExternalForm())
+          atts = attsImpl
+          atRoot = false
         }
-
+        super.startElement(uri, localName, qName, atts)
+      }
     }
-
   }
 
-  override def endElement (uri: String, localName: String, qName: String ) {
+  override def endElement(uri: String, localName: String, qName: String) {
     if (uri.equals(XINCLUDE_NAMESPACE)
         && localName.equals("include")) {
           level -= 1;
-        }
+    }
     else if (level == 0) {
-      bases.pop();
-      super.endElement(uri, localName, qName);
+      bases.pop()
+      super.endElement(uri, localName, qName)
     }
   }
 
   private var depth = 0;
 
   override def startDocument() {
-    level = 0;
-    if (depth == 0) super.startDocument();
+    level = 0
+    if (depth == 0) super.startDocument()
     depth += 1
   }
 
   override def endDocument() {
-    locators.pop();
+    locators.pop()
     bases.pop(); // pop the URL for the document itself
-    depth = depth - 1;
-    if (depth == 0) super.endDocument();
+    depth -= 1
+    if (depth == 0) super.endDocument()
   }
 
-    // how do prefix mappings move across documents????
-  override def startPrefixMapping(prefix: String , uri: String ): Unit = {
-    if (level == 0) super.startPrefixMapping(prefix, uri);
+  // how do prefix mappings move across documents????
+  override def startPrefixMapping(prefix: String , uri: String) {
+    if (level == 0) super.startPrefixMapping(prefix, uri)
   }
 
-  override def endPrefixMapping(prefix: String): Unit = {
-    if (level == 0) super.endPrefixMapping(prefix);
+  override def endPrefixMapping(prefix: String) {
+    if (level == 0) super.endPrefixMapping(prefix)
   }
 
-  override def characters(ch: Array[char], start: int, length: int): Unit = {
-    if (level == 0) super.characters(ch, start, length);
+  override def characters(ch: Array[Char], start: Int, length: Int) {
+    if (level == 0) super.characters(ch, start, length)
   }
 
-  override def ignorableWhitespace(ch: Array[char] , start: int, length: int): Unit = {
-    if (level == 0) super.ignorableWhitespace(ch, start, length);
+  override def ignorableWhitespace(ch: Array[Char], start: Int, length: Int) {
+    if (level == 0) super.ignorableWhitespace(ch, start, length)
   }
 
-  override def processingInstruction(target: String, data: String): Unit = {
-    if (level == 0) super.processingInstruction(target, data);
+  override def processingInstruction(target: String, data: String) {
+    if (level == 0) super.processingInstruction(target, data)
   }
 
-  override def skippedEntity(name: String): Unit =  {
-    if (level == 0) super.skippedEntity(name);
+  override def skippedEntity(name: String) {
+    if (level == 0) super.skippedEntity(name)
   }
 
   // convenience method for error messages
   private def getLocation(): String = {
-
-    var locationString = "";
-    val locator = locators.peek().asInstanceOf[Locator];
-    var publicID = "";
-    var systemID = "";
-    var column = -1;
-    var line = -1;
+    var locationString = ""
+    val locator = locators.peek().asInstanceOf[Locator]
+    var publicID = ""
+    var systemID = ""
+    var column = -1
+    var line = -1
     if (locator != null) {
-      publicID = locator.getPublicId();
-      systemID = locator.getSystemId();
-      line = locator.getLineNumber();
-      column = locator.getColumnNumber();
+      publicID = locator.getPublicId()
+      systemID = locator.getSystemId()
+      line = locator.getLineNumber()
+      column = locator.getColumnNumber()
     }
     locationString = (" in document included from " + publicID
     + " at " + systemID
     + " at line " + line + ", column " + column);
 
-    return locationString;
-
+    locationString
   }
 
-
   /**
     * <p>
     * This utility method reads a document at a specified URL
@@ -296,13 +291,13 @@ class XIncludeFilter extends XMLFilterImpl {
                            be downloaded from the specified URL
                            or if the encoding is not recognized
     */
-  private def includeTextDocument(url: String, encoding1: String): Unit = {
-    var encoding = encoding1;
+  private def includeTextDocument(url: String, encoding1: String) {
+    var encoding = encoding1
     if (encoding == null || encoding.trim().equals("")) encoding = "UTF-8";
-    var source: URL = null;
+    var source: URL = null
     try {
-      val base = bases.peek().asInstanceOf[URL];
-      source = new URL(base, url);
+      val base = bases.peek().asInstanceOf[URL]
+      source = new URL(base, url)
     }
     catch {
       case e: MalformedURLException =>
@@ -313,11 +308,12 @@ class XIncludeFilter extends XMLFilterImpl {
     }
 
     try {
-      val uc = source.openConnection();
-      val in = new BufferedInputStream(uc.getInputStream());
-      var encodingFromHeader = uc.getContentEncoding();
-      var contentType = uc.getContentType();
-      if (encodingFromHeader != null) encoding = encodingFromHeader;
+      val uc = source.openConnection()
+      val in = new BufferedInputStream(uc.getInputStream())
+      var encodingFromHeader = uc.getContentEncoding()
+      var contentType = uc.getContentType()
+      if (encodingFromHeader != null)
+        encoding = encodingFromHeader
       else {
         // What if file does not have a MIME type but name ends in .xml????
         // MIME types are case-insensitive
@@ -332,9 +328,9 @@ class XIncludeFilter extends XMLFilterImpl {
               }
         }
       }
-      val reader = new InputStreamReader(in, encoding);
-      val c = new Array[char](1024);
-      var charsRead: Int = 0; // bogus init value
+      val reader = new InputStreamReader(in, encoding)
+      val c = new Array[Char](1024)
+      var charsRead: Int = 0  // bogus init value
       do {
         charsRead = reader.read(c, 0, 1024);
         if (charsRead > 0) this.characters(c, 0, charsRead);
@@ -375,15 +371,15 @@ class XIncludeFilter extends XMLFilterImpl {
       case e:MalformedURLException =>
         val ex = new UnavailableResourceException("Unresolvable URL " + url
                                                   + getLocation());
-        ex.setRootCause(e);
-        throw new SAXException("Unresolvable URL " + url + getLocation(), ex);
+        ex.setRootCause(e)
+        throw new SAXException("Unresolvable URL " + url + getLocation(), ex)
     }
 
     try {
       // make this more robust
       var parser: XMLReader = null
       try {
-        parser = XMLReaderFactory.createXMLReader();
+        parser = XMLReaderFactory.createXMLReader()
       } catch {
         case e:SAXException =>
           try {
@@ -392,7 +388,7 @@ class XIncludeFilter extends XMLFilterImpl {
             );
           } catch {
             case e2: SAXException =>
-              System.err.println("Could not find an XML parser");
+              System.err.println("Could not find an XML parser")
           }
       }
       if(parser != null) {
diff --git a/src/library/scala/xml/include/sax/XIncluder.scala b/src/library/scala/xml/include/sax/XIncluder.scala
index f9e2ab1466..79c1807fb9 100644
--- a/src/library/scala/xml/include/sax/XIncluder.scala
+++ b/src/library/scala/xml/include/sax/XIncluder.scala
@@ -145,22 +145,22 @@ with ContentHandler with LexicalHandler {
   }
 
   // LexicalHandler methods
-  private var inDTD: boolean = false;
-  private val entities: Stack  = new Stack();
+  private var inDTD: Boolean = false
+  private val entities: Stack = new Stack()
 
-  def  startDTD(name: String, publicID: String, systemID: String): Unit = {
-    inDTD = true;
+  def startDTD(name: String, publicID: String, systemID: String) {
+    inDTD = true
     // if this is the source document, output a DOCTYPE declaration
     if (entities.size() == 0) {
-      var id = "";
+      var id = ""
       if (publicID != null) id = " PUBLIC \"" + publicID + "\" \"" + systemID + '"';
       else if (systemID != null) id = " SYSTEM \"" + systemID + '"';
       try {
-        out.write("<!DOCTYPE " + name + id + ">\r\n");
+        out.write("<!DOCTYPE " + name + id + ">\r\n")
       }
       catch {
         case e:IOException =>
-          throw new SAXException("Error while writing DOCTYPE", e);
+          throw new SAXException("Error while writing DOCTYPE", e)
       }
     }
   }
@@ -170,7 +170,6 @@ with ContentHandler with LexicalHandler {
     entities.push(name)
   }
 
-
   def endEntity(name: String) {
     entities.pop()
   }
@@ -180,14 +179,13 @@ with ContentHandler with LexicalHandler {
 
   // Just need this reference so we can ask if a comment is
   // inside an include element or not
-  private var filter: XIncludeFilter = null;
+  private var filter: XIncludeFilter = null
 
   def setFilter(filter: XIncludeFilter) {
     this.filter = filter
   }
 
   def comment(ch: Array[Char], start: Int, length: Int) {
-
     if (!inDTD && !filter.insideIncludeElement()) {
       try {
         out.write("<!--")
@@ -195,7 +193,7 @@ with ContentHandler with LexicalHandler {
         out.write("-->")
       }
       catch {
-        case e:IOException =>
+        case e: IOException =>
           throw new SAXException("Write failed", e)
       }
     }