removed leading/trailing blanks/tabs in nsc/tra...

removed leading/trailing blanks/tabs in nsc/transform/*.scala

5 files changed, 230 insertions, 193 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/LiftCode.scala b/src/compiler/scala/tools/nsc/transform/LiftCode.scala
index 9f94832cb0..fde24539a7 100644
--- a/src/compiler/scala/tools/nsc/transform/LiftCode.scala
+++ b/src/compiler/scala/tools/nsc/transform/LiftCode.scala
@@ -1,40 +1,47 @@
-/* NSC -- new scala compiler
- * Copyright 2005 LAMP/EPFL
- * @author
+/* NSC -- new Scala compiler
+ * Copyright 2005-2006 LAMP/EPFL
+ * @author Gilles Dubochet
  */
 // $Id$
-package scala.tools.nsc.transform;
 
-import symtab._;
-import Flags._;
-import util.TreeSet;
-import symtab.Flags._;
-import scala.collection.immutable.ListMap;
-import scala.collection.mutable.{HashMap, ListBuffer};
-import scala.tools.nsc.util.FreshNameCreator;
+package scala.tools.nsc.transform
 
+import symtab._
+import Flags._
+import symtab.Flags._
+import scala.collection.immutable.ListMap
+import scala.collection.mutable.{HashMap, ListBuffer}
+import scala.tools.nsc.util.{FreshNameCreator, TreeSet}
+
+/** This abstract class ...
+ *
+ *  @author Gilles Dubochet
+ *  @version 1.0
+ */
 abstract class LiftCode extends Transform {
 
-  import global._;                  // the global environment
-  import definitions._;             // standard classes and methods
-  import typer.{typed, atOwner};    // methods to type trees
-  import posAssigner.atPos;         // for filling in tree positions
+  import global._                  // the global environment
+  import definitions._             // standard classes and methods
+  import typer.{typed, atOwner}    // methods to type trees
+  import posAssigner.atPos         // for filling in tree positions
 
   /** the following two members override abstract members in Transform */
-  val phaseName: String = "liftcode";
+  val phaseName: String = "liftcode"
 
-  def newTransformer(unit: CompilationUnit): Transformer = new AddRefFields(unit);
+  def newTransformer(unit: CompilationUnit): Transformer =
+    new AddRefFields(unit)
 
   class AddRefFields(unit: CompilationUnit) extends Transformer {
     override def transform(tree: Tree): Tree = tree match {
-      case Apply(TypeApply(Select(x@Ident(_), nme.lift_), _), List(tree)) if x.symbol == CodeModule =>
+      case Apply(TypeApply(Select(x@Ident(_), nme.lift_), _), List(tree))
+      if x.symbol == CodeModule =>
         typed(atPos(tree.pos)(codify(tree)))
       case _ =>
         super.transform(tree)
     }
   }
 
-  case class FreeValue(tree: Tree) extends reflect.Tree;
+  case class FreeValue(tree: Tree) extends reflect.Tree
 
   class ReifyEnvironment extends HashMap[Symbol, reflect.Symbol] {
     var targets = new HashMap[String, Option[reflect.LabelSymbol]]()
@@ -212,7 +219,7 @@ abstract class LiftCode extends Transform {
 
   }
 
-  type InjectEnvironment = ListMap[reflect.Symbol, Name];
+  type InjectEnvironment = ListMap[reflect.Symbol, Name]
 
   class Injector(env: InjectEnvironment, fresh: FreshNameCreator) {
 
@@ -220,7 +227,10 @@ abstract class LiftCode extends Transform {
     def className(value: CaseClass): String = value match {
       case _ :: _ => "scala.$colon$colon"
       case reflect.MethodType(_, _) =>
-        if (value.isInstanceOf[reflect.ImplicitMethodType]) "scala.reflect.ImplicitMethodType" else "scala.reflect.MethodType"
+        if (value.isInstanceOf[reflect.ImplicitMethodType])
+          "scala.reflect.ImplicitMethodType"
+        else
+          "scala.reflect.MethodType"
       case x =>
         "scala.reflect."+x.caseName
       //case _ => // bq:unreachable code
@@ -228,27 +238,27 @@ abstract class LiftCode extends Transform {
     }
 
     def objectName(value: Any): String = value match {
-      case Nil => "scala.Nil"
-      case reflect.NoSymbol => "scala.reflect.NoSymbol"
+      case Nil                => "scala.Nil"
+      case reflect.NoSymbol   => "scala.reflect.NoSymbol"
       case reflect.RootSymbol => "scala.reflect.RootSymbol"
-      case reflect.NoPrefix => "scala.reflect.NoPrefix"
-      case reflect.NoType => "scala.reflect.NoType"
+      case reflect.NoPrefix   => "scala.reflect.NoPrefix"
+      case reflect.NoType     => "scala.reflect.NoType"
       case _ => ""
     }
 
     def inject(value: Any): Tree = value match {
       case FreeValue(tree) =>
         New(Ident(definitions.getClass("scala.reflect.Literal")), List(List(tree)))
-      case () => Literal(Constant(()))
-      case x: String => Literal(Constant(x))
-      case x: Boolean => Literal(Constant(x))
-      case x: Byte => Literal(Constant(x))
-      case x: Short => Literal(Constant(x))
-      case x: Char => Literal(Constant(x))
-      case x: Int => Literal(Constant(x))
-      case x: Long => Literal(Constant(x))
-      case x: Float => Literal(Constant(x))
-      case x: Double => Literal(Constant(x))
+      case ()           => Literal(Constant(()))
+      case x: String    => Literal(Constant(x))
+      case x: Boolean   => Literal(Constant(x))
+      case x: Byte      => Literal(Constant(x))
+      case x: Short     => Literal(Constant(x))
+      case x: Char      => Literal(Constant(x))
+      case x: Int       => Literal(Constant(x))
+      case x: Long      => Literal(Constant(x))
+      case x: Float     => Literal(Constant(x))
+      case x: Double    => Literal(Constant(x))
       case c: CaseClass =>
         val name = objectName(c);
         if (name.length() != 0) gen.mkAttributedRef(definitions.getModule(name))
@@ -260,20 +270,24 @@ abstract class LiftCode extends Transform {
             injectedArgs += inject(c.caseElement(i));
           New(Ident(definitions.getClass(name)), List(injectedArgs.toList))
         }
-      case null => gen.mkAttributedRef(definitions.getModule("scala.reflect.NoType"))
-      case _ => throw new Error("don't know how to inject " + value);
+      case null =>
+        gen.mkAttributedRef(definitions.getModule("scala.reflect.NoType"))
+      case _ =>
+        throw new Error("don't know how to inject " + value)
     }
 
   }
 
   def reify(tree: Tree): reflect.Tree =
-    new Reifier(new ReifyEnvironment(), reflect.NoSymbol).reify(tree);
+    new Reifier(new ReifyEnvironment(), reflect.NoSymbol).reify(tree)
 
   def inject(code: reflect.Tree): Tree =
-    new Injector(ListMap.Empty, new FreshNameCreator).inject(code);
+    new Injector(ListMap.Empty, new FreshNameCreator).inject(code)
 
   def codify (tree: Tree): Tree =
-    New(TypeTree(appliedType(definitions.CodeClass.typeConstructor, List(tree.tpe))),List(List(inject(reify(tree)))))
+    New(TypeTree(appliedType(definitions.CodeClass.typeConstructor,
+                             List(tree.tpe))),
+        List(List(inject(reify(tree)))))
 
 }
 
@@ -311,4 +325,3 @@ abstract class LiftCode extends Transform {
 // case Alternative(trees) =>
 // case Star(elem) =>
 // case Bind(name, body) =>
-
diff --git a/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala b/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala
index fc3aaacaef..00d0c2a469 100644
--- a/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala
+++ b/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala
@@ -1,41 +1,50 @@
-/* NSC -- new scala compiler
- * Copyright 2005 LAMP/EPFL
- * @author
+/* NSC -- new Scala compiler
+ * Copyright 2005-2006 LAMP/EPFL
+ * @author Martin Odersky
  */
 // $Id$
-package scala.tools.nsc.transform;
 
-import util.HashSet;
-import collection.mutable.HashMap;
-import symtab.Flags._;
+package scala.tools.nsc.transform
 
+import collection.mutable.HashMap
+import symtab.Flags._
+import util.HashSet
+
+/** This abstract class ...
+ *
+ *  @author Martin Odersky
+ *  @version 1.0
+ */
 abstract class OverridingPairs {
 
-  val global: Global;
-  import global._;
+  val global: Global
+  import global._
 
   class Cursor(base: Symbol) {
 
-    private val self = base.thisType;
+    private val self = base.thisType
 
-    protected def exclude(sym: Symbol): boolean = sym.isConstructor || (sym hasFlag LOCAL);
+    protected def exclude(sym: Symbol): boolean =
+      sym.isConstructor || (sym hasFlag LOCAL)
 
-    protected def parents: List[Type] = base.info.parents;
+    protected def parents: List[Type] = base.info.parents
 
     protected def matches(sym1: Symbol, sym2: Symbol): boolean =
-      sym1.isType || (self.memberType(sym1) matches self.memberType(sym2));
+      sym1.isType || (self.memberType(sym1) matches self.memberType(sym2))
 
-    private type BitSet = Array[int];
+    private type BitSet = Array[int]
 
-    private def newBitSet(size: int): BitSet = new Array((size + 31) >> 5);
+    private def newBitSet(size: int): BitSet = new Array((size + 31) >> 5)
 
     private def include(bs: BitSet, n: int): unit = {
-      val nshifted = n >> 5;
-      val nmask = 1 << (n & 31);
+      val nshifted = n >> 5
+      val nmask = 1 << (n & 31)
       bs(nshifted) = bs(nshifted) | nmask
     }
 
-    private def intersectionContainsElementLeq(bs1: BitSet, bs2: BitSet, n: int): boolean = {
+    private def intersectionContainsElementLeq(bs1: BitSet, bs2: BitSet,
+                                               n: int): boolean =
+    {
       val nshifted = n >> 5;
       val nmask = 1 << (n & 31);
       ((List.range(0, nshifted) exists (i => (bs1(i) & bs2(i)) != 0)) ||
@@ -45,33 +54,34 @@ abstract class OverridingPairs {
     private val decls = new Scope;
     { def fillDecls(bcs: List[Symbol], deferredflag: int): unit =
         if (!bcs.isEmpty) {
-	  fillDecls(bcs.tail, deferredflag);
-	  var e = bcs.head.info.decls.elems;
-	  while (e != null) {
-	    if (e.sym.getFlag(DEFERRED) == deferredflag && !exclude(e.sym)) decls enter e.sym;
-	    e = e.next
-	  }
-	}
-      fillDecls(base.info.baseClasses, DEFERRED);
-      fillDecls(base.info.baseClasses, 0);
+          fillDecls(bcs.tail, deferredflag)
+          var e = bcs.head.info.decls.elems;
+          while (e != null) {
+            if (e.sym.getFlag(DEFERRED) == deferredflag && !exclude(e.sym))
+              decls enter e.sym;
+            e = e.next
+          }
+        }
+      fillDecls(base.info.baseClasses, DEFERRED)
+      fillDecls(base.info.baseClasses, 0)
     }
 
-    private val size = base.info.baseClasses.length;
+    private val size = base.info.baseClasses.length
 
-    private val index = new HashMap[Symbol, int];
+    private val index = new HashMap[Symbol, int]
     { var i = 0;
       for (val bc <- base.info.baseClasses) {
-	index(bc) = i;
-	i = i + 1
+        index(bc) = i
+        i = i + 1
       }
     }
 
-    private val subParents = new Array[BitSet](size);
+    private val subParents = new Array[BitSet](size)
     { for (val i <- List.range(0, size))
-	subParents(i) = new BitSet(size);
+        subParents(i) = new BitSet(size);
       for (val p <- parents) {
-        val pIndex = index(p.symbol);
-        for (val bc <- p.baseClasses) include(subParents(index(bc)), pIndex);
+        val pIndex = index(p.symbol)
+        for (val bc <- p.baseClasses) include(subParents(index(bc)), pIndex)
       }
     }
 
@@ -79,45 +89,45 @@ abstract class OverridingPairs {
     private def hasCommonParent(sym1: Symbol, sym2: Symbol) = {
       //assert(index.get(sym1.owner) != None, "" + base + " " + sym1 + " " + sym1.owner);//DEBUG
       //assert(index.get(sym2.owner) != None, "" + base + " " + sym2 + " " + sym2.owner);//DEBUG
-      val index1 = index(sym1.owner);
-      val index2 = index(sym2.owner);
-      val minindex = if (index1 < index2) index1 else index2;
+      val index1 = index(sym1.owner)
+      val index2 = index(sym2.owner)
+      val minindex = if (index1 < index2) index1 else index2
       intersectionContainsElementLeq(subParents(index1), subParents(index2), minindex)
     }
 
-    private val visited = new HashSet[ScopeEntry](256);
-    private var curEntry = decls.elems;
-    private var nextEntry = curEntry;
+    private val visited = new HashSet[ScopeEntry](256)
+    private var curEntry = decls.elems
+    private var nextEntry = curEntry
 
-    var overriding: Symbol = _;
-    var overridden: Symbol = _;
+    var overriding: Symbol = _
+    var overridden: Symbol = _
 
-    def hasNext: boolean = curEntry != null;
+    def hasNext: boolean = curEntry != null
 
     def next: unit =
       if (curEntry != null) {
-	overriding = curEntry.sym;
-	if (nextEntry != null) {
-	  do {
-	    nextEntry = decls.lookupNextEntry(nextEntry);
-	  } while (nextEntry != null &&
-		   ((nextEntry.sym hasFlag PRIVATE) ||
-		    (overriding.owner == nextEntry.sym.owner) ||
-		    (!matches(overriding, nextEntry.sym)) ||
-		    (hasCommonParent(overriding, nextEntry.sym)) ||
-		    (overriding hasFlag LOCAL)))
-	}
-	if (nextEntry != null) {
-	  overridden = nextEntry.sym;
-	  //System.out.println("yield: " + overriding + overriding.locationString + " / " + overridden + overridden.locationString);//DEBUG
-	  visited addEntry nextEntry
-	} else {
-	  do {
-	    curEntry = curEntry.next
-	  } while (curEntry != null && (visited contains curEntry));
-	  nextEntry = curEntry;
-	  next
-	}
+        overriding = curEntry.sym
+        if (nextEntry != null) {
+          do {
+            nextEntry = decls.lookupNextEntry(nextEntry);
+          } while (nextEntry != null &&
+                   ((nextEntry.sym hasFlag PRIVATE) ||
+                    (overriding.owner == nextEntry.sym.owner) ||
+                    (!matches(overriding, nextEntry.sym)) ||
+                    (hasCommonParent(overriding, nextEntry.sym)) ||
+                    (overriding hasFlag LOCAL)))
+        }
+        if (nextEntry != null) {
+          overridden = nextEntry.sym;
+          //System.out.println("yield: " + overriding + overriding.locationString + " / " + overridden + overridden.locationString);//DEBUG
+          visited addEntry nextEntry
+        } else {
+          do {
+            curEntry = curEntry.next
+          } while (curEntry != null && (visited contains curEntry));
+          nextEntry = curEntry
+          next
+        }
       }
 
     next
diff --git a/src/compiler/scala/tools/nsc/transform/SampleTransform.scala b/src/compiler/scala/tools/nsc/transform/SampleTransform.scala
index 404e03e572..8c1f4934df 100644
--- a/src/compiler/scala/tools/nsc/transform/SampleTransform.scala
+++ b/src/compiler/scala/tools/nsc/transform/SampleTransform.scala
@@ -1,23 +1,26 @@
-/* NSC -- new scala compiler
- * Copyright 2005 LAMP/EPFL
- * @author
+/* NSC -- new Scala compiler
+ * Copyright 2005-2006 LAMP/EPFL
+ * @author Martin Odersky
  */
 // $Id$
-package scala.tools.nsc.transform;
+
+package scala.tools.nsc.transform
 
 /** A sample transform.
  */
 abstract class SampleTransform extends Transform {
   // inherits abstract value `global' and class `Phase' from Transform
 
-  import global._;                  // the global environment
-  import definitions._;             // standard classes and methods
-  import typer.{typed, atOwner};               // methods to type trees
-  import posAssigner.atPos;         // for filling in tree positions
+  import global._                  // the global environment
+  import definitions._             // standard classes and methods
+  import typer.{typed, atOwner}    // methods to type trees
+  import posAssigner.atPos         // for filling in tree positions
 
   /** the following two members override abstract members in Transform */
-  val phaseName: String = "sample-phase";
-  protected def newTransformer(unit: CompilationUnit): Transformer = new SampleTransformer(unit);
+  val phaseName: String = "sample-phase"
+
+  protected def newTransformer(unit: CompilationUnit): Transformer =
+    new SampleTransformer(unit)
 
   class SampleTransformer(unit: CompilationUnit) extends Transformer {
 
diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
index ccd1acebca..49c950363a 100644
--- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala
+++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
@@ -1,34 +1,41 @@
 /* NSC -- new scala compiler
  * Copyright 2005 LAMP/EPFL
- * @author
+ * @author Iulian Dragos
  */
 // $Id$
+
 package scala.tools.nsc.transform;
 
 import scala.tools.nsc.symtab.Flags;
 
 /** Perform tail recursive call elimination.
+ *
+ *  @author Iulian Dragos
+ *  @version 1.0
  */
 abstract class TailCalls extends Transform
                          /* with JavaLogging() */ {
   // inherits abstract value `global' and class `Phase' from Transform
 
-  import global._;                  // the global environment
-  import definitions._;             // standard classes and methods
-  import typer.{typed, atOwner};               // methods to type trees
-  import posAssigner.atPos;         // for filling in tree positions
+  import global._                  // the global environment
+  import definitions._             // standard classes and methods
+  import typer.{typed, atOwner}    // methods to type trees
+  import posAssigner.atPos         // for filling in tree positions
+
+  val phaseName: String = "tailcalls"
 
-  val phaseName: String = "tailcalls";
-  def newTransformer(unit: CompilationUnit): Transformer = new TailCallElimination(unit);
+  def newTransformer(unit: CompilationUnit): Transformer =
+    new TailCallElimination(unit)
 
   /** Create a new phase which applies transformer */
-  override def newPhase(prev: scala.tools.nsc.Phase): StdPhase = new Phase(prev);
+  override def newPhase(prev: scala.tools.nsc.Phase): StdPhase = new Phase(prev)
 
   /** The phase defined by this transform */
   class Phase(prev: scala.tools.nsc.Phase) extends StdPhase(prev) {
-    def apply(unit: global.CompilationUnit): unit = if (!(settings.debuginfo.value == "notc")) {
-      newTransformer(unit).transformUnit(unit);
-    }
+    def apply(unit: global.CompilationUnit): unit =
+      if (!(settings.debuginfo.value == "notc")) {
+        newTransformer(unit).transformUnit(unit);
+      }
   }
 
 
@@ -74,51 +81,51 @@ abstract class TailCalls extends Transform
 
     class Context {
       /** The current method */
-      var currentMethod: Symbol = NoSymbol;
+      var currentMethod: Symbol = NoSymbol
 
       /** The current tail-call label */
-      var label: Symbol = NoSymbol;
+      var label: Symbol = NoSymbol
 
       /** The expected type arguments of self-recursive calls */
-      var tparams: List[Symbol] = Nil;
+      var tparams: List[Symbol] = Nil
 
       /** Tells whether we are in a (possible) tail position */
-      var tailPos = false;
+      var tailPos = false
 
       /** Is the label accessed? */
-      var accessed = false;
+      var accessed = false
 
       def this(that: Context) = {
-        this();
-        this.currentMethod = that.currentMethod;
-        this.label         = that.label;
-        this.tparams       = that.tparams;
-        this.tailPos       = that.tailPos;
-        this.accessed      = that.accessed;
+        this()
+        this.currentMethod = that.currentMethod
+        this.label         = that.label
+        this.tparams       = that.tparams
+        this.tailPos       = that.tailPos
+        this.accessed      = that.accessed
       }
 
       /** Create a new method symbol for the current method and store it in
         * the label field.
         */
       def makeLabel(): Unit = {
-        label = currentMethod.newLabel(currentMethod.pos, "_" + currentMethod.name);
-        accessed = false;
+        label = currentMethod.newLabel(currentMethod.pos, "_" + currentMethod.name)
+        accessed = false
       }
 
       override def toString(): String = (
         "" + currentMethod.name + " tparams: " + tparams + " tailPos: " + tailPos +
         " accessed: " + accessed + "\nLabel: " + label + "\nLabel type: " + label.info
-      );
+      )
     }
 
-    private def mkContext(that: Context) = new Context(that);
+    private def mkContext(that: Context) = new Context(that)
     private def mkContext(that: Context, tp: Boolean): Context = {
-      val t = mkContext(that);
-      t.tailPos = tp;
+      val t = mkContext(that)
+      t.tailPos = tp
       t
     }
 
-    private var ctx: Context = new Context();
+    private var ctx: Context = new Context()
 
     /** Rewrite this tree to contain no tail recursive calls */
     def transform(tree: Tree, nctx: Context): Tree = {
@@ -133,23 +140,23 @@ abstract class TailCalls extends Transform
       tree match {
 
         case DefDef(mods, name, tparams, vparams, tpt, rhs) =>
-          log("Entering DefDef: " + name);
-          val newCtx = mkContext(ctx);
-          newCtx.currentMethod = tree.symbol;
-          newCtx.makeLabel();
-          newCtx.label.setInfo(tree.symbol.info);
-          newCtx.tailPos = true;
+          log("Entering DefDef: " + name)
+          val newCtx = mkContext(ctx)
+          newCtx.currentMethod = tree.symbol
+          newCtx.makeLabel()
+          newCtx.label.setInfo(tree.symbol.info)
+          newCtx.tailPos = true
 
           val t1 = if (newCtx.currentMethod.isFinal ||
                        newCtx.currentMethod.enclClass.hasFlag(Flags.MODULE)) {
-            newCtx.tparams = Nil;
-            log("  Considering " + name + " for tailcalls");
+            newCtx.tparams = Nil
+            log("  Considering " + name + " for tailcalls")
             tree.symbol.tpe match {
               case PolyType(tpes, restpe) =>
-                newCtx.tparams = tparams map (.symbol);
+                newCtx.tparams = tparams map (.symbol)
                 newCtx.label.setInfo(
-                  restpe.substSym(tpes, tparams map (.symbol)));
-              case _ => ();
+                  restpe.substSym(tpes, tparams map (.symbol)))
+              case _ => ()
             }
 
             var newRHS = transform(rhs, newCtx);
@@ -170,29 +177,29 @@ abstract class TailCalls extends Transform
           log("Leaving DefDef: " + name);
           t1;
 
-        case EmptyTree => tree;
+        case EmptyTree => tree
 
-        case PackageDef(name, stats) => super.transform(tree);
+        case PackageDef(name, stats) => super.transform(tree)
         case ClassDef(mods, name, tparams, tpt, impl) =>
-          log("Entering class " + name);
-          val res = super.transform(tree);
-          log("Leaving class " + name);
+          log("Entering class " + name)
+          val res = super.transform(tree)
+          log("Leaving class " + name)
           res
 
-        case ValDef(mods, name, tpt, rhs) => tree;
-        case AbsTypeDef(mods, name, lo, hi) => tree; //  (eliminated by erasure)
-        case AliasTypeDef(mods, name, tparams, rhs) => tree; // (eliminated by erasure)
-        case LabelDef(name, params, rhs) => super.transform(tree);
+        case ValDef(mods, name, tpt, rhs) => tree
+        case AbsTypeDef(mods, name, lo, hi) => tree //  (eliminated by erasure)
+        case AliasTypeDef(mods, name, tparams, rhs) => tree // (eliminated by erasure)
+        case LabelDef(name, params, rhs) => super.transform(tree)
 
-        case Template(parents, body) => super.transform(tree);
+        case Template(parents, body) => super.transform(tree)
 
         case Block(stats, expr) =>
           copy.Block(tree,
                      transformTrees(stats, mkContext(ctx, false)),
-                     transform(expr));
+                     transform(expr))
 
         case CaseDef(pat, guard, body) =>
-          copy.CaseDef(tree, pat, guard, transform(body));
+          copy.CaseDef(tree, pat, guard, transform(body))
 
         case Sequence(_) | Alternative(_) |
              Star(_)     | Bind(_, _) =>
@@ -209,12 +216,12 @@ abstract class TailCalls extends Transform
         case Match(selector, cases) => //super.transform(tree);
           copy.Match(tree, transform(selector, mkContext(ctx, false)), transformTrees(cases).asInstanceOf[List[CaseDef]]);
 
-        case Return(expr) =>           super.transform(tree);
-        case Try(block, catches, finalizer) => super.transform(tree);
+        case Return(expr) => super.transform(tree)
+        case Try(block, catches, finalizer) => super.transform(tree)
 
-        case Throw(expr) => super.transform(tree);
-        case New(tpt) => super.transform(tree);
-        case Typed(expr, tpt) => super.transform(tree);
+        case Throw(expr) => super.transform(tree)
+        case New(tpt) => super.transform(tree)
+        case Typed(expr, tpt) => super.transform(tree)
 
         case Apply(tapply @ TypeApply(fun, targs), vargs) =>
           if ( ctx.currentMethod.isFinal &&
@@ -226,7 +233,7 @@ abstract class TailCalls extends Transform
                  copy.Apply(tree, tapply, transformTrees(vargs, mkContext(ctx, false)));
 
         case TypeApply(fun, args) =>
-          super.transform(tree);
+          super.transform(tree)
 //          throw new RuntimeException("Lonely TypeApply found -- we can only handle them inside Apply(TypeApply()): " + tree + " at: " + unit);
 
         case Apply(fun, args) =>
@@ -238,24 +245,24 @@ abstract class TailCalls extends Transform
             copy.Apply(tree, fun, transformTrees(args, mkContext(ctx, false)));
 
         case Super(qual, mix) =>
-          tree;
+          tree
         case This(qual) =>
-          tree;
+          tree
         case Select(qualifier, selector) =>
-          tree;
+          tree
         case Ident(name) =>
-          tree;
+          tree
         case Literal(value) =>
-          tree;
-        case TypeTree() =>  tree;
-
+          tree
+        case TypeTree() =>
+          tree
         case _ =>
           tree
       }
     }
 
     def transformTrees(trees: List[Tree], nctx: Context): List[Tree] =
-      trees map ((tree) => transform(tree, nctx));
+      trees map ((tree) => transform(tree, nctx))
 
     private def rewriteTailCall(fun: Tree, args: List[Tree]): Tree = {
       log("Rewriting tail recursive method call at: " +
@@ -281,11 +288,11 @@ abstract class TailCalls extends Transform
         fun match {
           case Select(t @ This(_), _) =>
             assert(t.symbol == ctx.currentMethod.owner, "This refers to other class: " +
-                   t.symbol + ": " + ctx.currentMethod.owner);
-            true;
+                   t.symbol + ": " + ctx.currentMethod.owner)
+            true
 
-          case Ident(_) => true;
-          case _ => false;
+          case Ident(_) => true
+          case _ => false
         }
     else
       false;
diff --git a/src/compiler/scala/tools/nsc/transform/Transform.scala b/src/compiler/scala/tools/nsc/transform/Transform.scala
index cfdf796f27..9aefaf7a8d 100644
--- a/src/compiler/scala/tools/nsc/transform/Transform.scala
+++ b/src/compiler/scala/tools/nsc/transform/Transform.scala
@@ -1,25 +1,29 @@
-/* NSC -- new scala compiler
- * Copyright 2005 LAMP/EPFL
- * @author
+/* NSC -- new Scala compiler
+ * Copyright 2005-2006 LAMP/EPFL
+ * @author Martin Odersky
  */
 // $Id$
+
 package scala.tools.nsc.transform;
 
 /** A base class for transforms.
  *  A transform contains a compiler phase which applies a tree transformer.
+ *
+ *  @author Martin Odersky
+ *  @version 1.0
  */
 abstract class Transform extends SubComponent {
 
   /** The transformer factory */
-  protected def newTransformer(unit: global.CompilationUnit): global.Transformer;
+  protected def newTransformer(unit: global.CompilationUnit): global.Transformer
 
   /** Create a new phase which applies transformer */
-  def newPhase(prev: scala.tools.nsc.Phase): StdPhase = new Phase(prev);
+  def newPhase(prev: scala.tools.nsc.Phase): StdPhase = new Phase(prev)
 
   /** The phase defined by this transform */
   class Phase(prev: scala.tools.nsc.Phase) extends StdPhase(prev) {
     def apply(unit: global.CompilationUnit): unit = {
-      newTransformer(unit).transformUnit(unit);
+      newTransformer(unit).transformUnit(unit)
     }
   }
 }