removed leading/trailing tabs/blanks in files C...

removed leading/trailing tabs/blanks in files Constructors.scala and
LambdaLift.scala

2 files changed, 221 insertions, 210 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index 1d167f78b3..34627ce939 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -1,78 +1,79 @@
-/* NSC -- new scala compiler
- * Copyright 2005 LAMP/EPFL
+/* NSC -- new Scala compiler
+ * Copyright 2005-2006 LAMP/EPFL
  * @author
  */
 // $Id$
-package scala.tools.nsc.transform;
 
-import symtab._;
-import Flags._;
-import scala.collection.mutable.ListBuffer;
-import util.TreeSet;
+package scala.tools.nsc.transform
+
+import symtab._
+import Flags._
+import scala.collection.mutable.ListBuffer
+import util.TreeSet
 
 abstract class Constructors extends Transform {
-  import global._;
-  import definitions._;
-  import posAssigner.atPos;
+  import global._
+  import definitions._
+  import posAssigner.atPos
 
   /** the following two members override abstract members in Transform */
-  val phaseName: String = "constructors";
+  val phaseName: String = "constructors"
 
-  protected def newTransformer(unit: CompilationUnit): Transformer = new ConstructorTransformer;
+  protected def newTransformer(unit: CompilationUnit): Transformer = new ConstructorTransformer
 
   class ConstructorTransformer extends Transformer {
 
     def transformClassTemplate(impl: Template): Template = {
-      val clazz = impl.symbol.owner;
-      val stats = impl.body;
-      val localTyper = typer.atOwner(impl, clazz);
-      var constr: DefDef = null;
-      var constrParams: List[Symbol] = null;
-      var constrBody: Block = null;
+      val clazz = impl.symbol.owner
+      val stats = impl.body
+      val localTyper = typer.atOwner(impl, clazz)
+      var constr: DefDef = null
+      var constrParams: List[Symbol] = null
+      var constrBody: Block = null
       // decompose primary constructor into the three entities above.
       for (val stat <- stats) {
-	stat match {
-	  case ddef @ DefDef(_, _, _, List(vparams), _, rhs @ Block(_, Literal(_))) =>
-	    if (ddef.symbol.isPrimaryConstructor) {
-	      constr = ddef;
-	      constrParams = vparams map (.symbol);
-	      constrBody = rhs
-	    }
-	  case _ =>
-	}
+        stat match {
+          case ddef @ DefDef(_, _, _, List(vparams), _, rhs @ Block(_, Literal(_))) =>
+            if (ddef.symbol.isPrimaryConstructor) {
+              constr = ddef;
+              constrParams = vparams map (.symbol);
+              constrBody = rhs
+            }
+          case _ =>
+        }
       }
 
-      val paramAccessors = clazz.constrParamAccessors;
+      val paramAccessors = clazz.constrParamAccessors
       def parameter(acc: Symbol) = {
-        val accname = nme.getterName(acc.originalName);
+        val accname = nme.getterName(acc.originalName)
         val ps = constrParams.filter { param => accname == param.name }
         if (ps.isEmpty) assert(false, "" + accname + " not in " + constrParams);
         ps.head
       }
 
-      var thisRefSeen: boolean = false;
+      var thisRefSeen: boolean = false
 
       val intoConstructorTransformer = new Transformer {
-	override def transform(tree: Tree): Tree = tree match {
-	  case Apply(Select(This(_), _), List())
-	  if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz) =>
+        override def transform(tree: Tree): Tree = tree match {
+          case Apply(Select(This(_), _), List())
+          if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz) =>
             gen.Ident(parameter(tree.symbol.accessed)) setPos tree.pos;
-	  case Select(This(_), _)
-	  if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz) =>
-	    gen.Ident(parameter(tree.symbol)) setPos tree.pos;
+          case Select(This(_), _)
+          if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz) =>
+            gen.Ident(parameter(tree.symbol)) setPos tree.pos;
           case This(_) =>
             thisRefSeen = true;
             super.transform(tree)
           case Super(_, _) =>
             thisRefSeen = true;
             super.transform(tree)
-	  case _ =>
-	    super.transform(tree)
-	}
+          case _ =>
+            super.transform(tree)
+        }
       }
 
       def intoConstructor(oldowner: Symbol, tree: Tree) =
-	intoConstructorTransformer.transform(
+        intoConstructorTransformer.transform(
           new ChangeOwnerTraverser(oldowner, constr.symbol)(tree));
 
       def canBeMoved(tree: Tree) = tree match {
@@ -81,18 +82,18 @@ abstract class Constructors extends Transform {
       }
 
       def mkAssign(to: Symbol, from: Tree): Tree =
-	atPos(to.pos) {
-	  localTyper.typed {
-	    Assign(Select(This(clazz), to), from)
-	  }
-	}
+        atPos(to.pos) {
+          localTyper.typed {
+            Assign(Select(This(clazz), to), from)
+          }
+      }
 
       def copyParam(to: Symbol, from: Symbol): Tree = {
         var result = mkAssign(to, Ident(from));
         if (from.name == nme.OUTER)
           result =
             atPos(to.pos) {
-	      localTyper.typed {
+              localTyper.typed {
                 If(Apply(Select(Ident(from), nme.eq), List(Literal(Constant(null)))),
                    Throw(New(TypeTree(NullPointerExceptionClass.tpe), List(List()))),
                    result);
@@ -101,66 +102,66 @@ abstract class Constructors extends Transform {
         result
       }
 
-      val defBuf = new ListBuffer[Tree];
-      val constrStatBuf = new ListBuffer[Tree];
-      val constrPrefixBuf = new ListBuffer[Tree];
-      constrBody.stats foreach (constrStatBuf +=);
+      val defBuf = new ListBuffer[Tree]
+      val constrStatBuf = new ListBuffer[Tree]
+      val constrPrefixBuf = new ListBuffer[Tree]
+      constrBody.stats foreach (constrStatBuf +=)
 
       for (val stat <- stats) stat match {
-	case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
-	  stat.symbol.tpe match {
-	    case MethodType(List(), tp @ ConstantType(c)) =>
-	      defBuf += copy.DefDef(
-		stat, mods, name, tparams, vparamss, tpt,
-		Literal(c) setPos rhs.pos setType tp)
-	    case _ =>
-	      if (!stat.symbol.isPrimaryConstructor) defBuf += stat
-	  }
-	case ValDef(mods, name, tpt, rhs) =>
-	  if (stat.symbol.tpe.isInstanceOf[ConstantType])
-	    assert(stat.symbol.getter(stat.symbol.owner) != NoSymbol, stat)
-	  else {
-	    if (rhs != EmptyTree) {
+        case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
+          stat.symbol.tpe match {
+            case MethodType(List(), tp @ ConstantType(c)) =>
+              defBuf += copy.DefDef(
+                stat, mods, name, tparams, vparamss, tpt,
+                Literal(c) setPos rhs.pos setType tp)
+            case _ =>
+              if (!stat.symbol.isPrimaryConstructor) defBuf += stat
+          }
+        case ValDef(mods, name, tpt, rhs) =>
+          if (stat.symbol.tpe.isInstanceOf[ConstantType])
+            assert(stat.symbol.getter(stat.symbol.owner) != NoSymbol, stat)
+          else {
+            if (rhs != EmptyTree) {
               val rhs1 = intoConstructor(stat.symbol, rhs);
               (if (canBeMoved(stat)) constrPrefixBuf else constrStatBuf) += mkAssign(
                 stat.symbol, rhs1)
-	    }
-	    defBuf += copy.ValDef(stat, mods, name, tpt, EmptyTree)
-	  }
+            }
+            defBuf += copy.ValDef(stat, mods, name, tpt, EmptyTree)
+          }
         case ClassDef(_, _, _, _, _) =>
           defBuf += (new ConstructorTransformer).transform(stat)
-	case _ =>
-	  constrStatBuf += intoConstructor(impl.symbol, stat)
+        case _ =>
+          constrStatBuf += intoConstructor(impl.symbol, stat)
       }
 
-      val accessed = new TreeSet[Symbol]((x, y) => x isLess y);
+      val accessed = new TreeSet[Symbol]((x, y) => x isLess y)
 
       def isAccessed(sym: Symbol) = (
-	sym.owner != clazz ||
-	!(sym hasFlag PARAMACCESSOR) ||
-	!(sym hasFlag LOCAL) ||
-	(accessed contains sym)
+        sym.owner != clazz ||
+        !(sym hasFlag PARAMACCESSOR) ||
+        !(sym hasFlag LOCAL) ||
+        (accessed contains sym)
       );
 
       val accessTraverser = new Traverser {
         override def traverse(tree: Tree) = {
-	  tree match {
+          tree match {
             case Select(_, _) =>
-              if (!isAccessed(tree.symbol)) accessed addEntry tree.symbol;
+              if (!isAccessed(tree.symbol)) accessed addEntry tree.symbol
             case _ =>
           }
           super.traverse(tree)
-	}
+        }
       }
 
       for (val stat <- defBuf.elements) accessTraverser.traverse(stat);
 
       val paramInits = for (val acc <- paramAccessors; isAccessed(acc))
-		       yield copyParam(acc, parameter(acc))
+                       yield copyParam(acc, parameter(acc))
 
       defBuf += copy.DefDef(
-	constr, constr.mods, constr.name, constr.tparams, constr.vparamss, constr.tpt,
-	copy.Block(
+        constr, constr.mods, constr.name, constr.tparams, constr.vparamss, constr.tpt,
+        copy.Block(
           constrBody,
           paramInits ::: constrPrefixBuf.toList ::: constrStatBuf.toList,
           constrBody.expr));
@@ -168,11 +169,15 @@ abstract class Constructors extends Transform {
       copy.Template(impl, impl.parents, defBuf.toList filter (stat => isAccessed(stat.symbol)))
     }
 
-    override def transform(tree: Tree): Tree = tree match {
-      case ClassDef(mods, name, tparams, tpt, impl) if !tree.symbol.hasFlag(INTERFACE) =>
-	copy.ClassDef(tree, mods, name, tparams, tpt, transformClassTemplate(impl))
-      case _ =>
-        super.transform(tree)
+    override def transform(tree: Tree): Tree = {
+      tree match {
+        case ClassDef(mods, name, tparams, tpt, impl) if !tree.symbol.hasFlag(INTERFACE) =>
+          copy.ClassDef(tree, mods, name, tparams, tpt, transformClassTemplate(impl))
+        case _ =>
+          super.transform(tree)
+      }
     }
-  }
+
+  } // ConstructorTransformer
+
 }
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index 6513c085bd..ccd30c1728 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -1,68 +1,69 @@
-/* NSC -- new scala compiler
- * Copyright 2005 LAMP/EPFL
+/* NSC -- new Scala compiler
+ * Copyright 2005-2006 LAMP/EPFL
  * @author
  */
 // $Id$
-package scala.tools.nsc.transform;
 
-import symtab._;
-import Flags._;
-import util.TreeSet;
-import scala.collection.mutable.{HashMap, ListBuffer};
+package scala.tools.nsc.transform
+
+import symtab._
+import Flags._
+import util.TreeSet
+import scala.collection.mutable.{HashMap, ListBuffer}
 
 abstract class LambdaLift extends InfoTransform {
-  import global._;
-  import definitions._;
-  import typer.{typed, typedOperator};
-  import posAssigner.atPos;
+  import global._
+  import definitions._
+  import typer.{typed, typedOperator}
+  import posAssigner.atPos
 
   /** the following two members override abstract members in Transform */
-  val phaseName: String = "lambdalift";
+  val phaseName: String = "lambdalift"
 
   private val lifted = new TypeMap {
     def apply(tp: Type): Type = tp match {
       case TypeRef(pre, sym, args) =>
-	if (pre == NoPrefix && sym.isClass && !sym.isPackageClass) {
+        if (pre == NoPrefix && sym.isClass && !sym.isPackageClass) {
           assert(args.isEmpty);
           typeRef(apply(sym.owner.enclClass.thisType), sym, args)
-	} else mapOver(tp)
+        } else mapOver(tp)
       case ClassInfoType(parents, decls, clazz) =>
-	val parents1 = List.mapConserve(parents)(this);
-	if (parents1 eq parents) tp
-	else ClassInfoType(parents1, decls, clazz)
+        val parents1 = List.mapConserve(parents)(this)
+        if (parents1 eq parents) tp
+        else ClassInfoType(parents1, decls, clazz)
       case _ =>
         mapOver(tp)
     }
   }
 
-  def transformInfo(sym: Symbol, tp: Type): Type = lifted(tp);
+  def transformInfo(sym: Symbol, tp: Type): Type = lifted(tp)
 
   protected def newTransformer(unit: CompilationUnit): Transformer =
-    new LambdaLifter(unit);
+    new LambdaLifter(unit)
 
   class LambdaLifter(unit: CompilationUnit) extends explicitOuter.OuterPathTransformer {
 
     /** A map storing free variables of functions and classes */
-    private val free = new HashMap[Symbol,SymSet];
+    private val free = new HashMap[Symbol, SymSet]
 
     /** A map storing the free variable proxies of functions and classes */
-    private val proxies = new HashMap[Symbol, List[Symbol]];
+    private val proxies = new HashMap[Symbol, List[Symbol]]
 
     /** A hashtable storing calls between functions */
-    private val called = new HashMap[Symbol, SymSet];
+    private val called = new HashMap[Symbol, SymSet]
 
     /** The set of symbols that need to be renamed. */
-    private val renamable = newSymSet;
+    private val renamable = newSymSet
 
     /** A flag to indicate whether new free variables have been found */
-    private var changedFreeVars: boolean = _;
+    private var changedFreeVars: boolean = _
 
     /** Buffers for lifted out classes and methods */
-    private val liftedDefs = new HashMap[Symbol, ListBuffer[Tree]];
+    private val liftedDefs = new HashMap[Symbol, ListBuffer[Tree]]
 
-    private type SymSet = TreeSet[Symbol];
+    private type SymSet = TreeSet[Symbol]
 
-    private def newSymSet = new TreeSet[Symbol]((x, y) => x.isLess(y));
+    private def newSymSet = new TreeSet[Symbol]((x, y) => x.isLess(y))
 
     private def symSet(f: HashMap[Symbol, SymSet], sym: Symbol): SymSet = f.get(sym) match {
       case Some(ss) => ss
@@ -74,8 +75,8 @@ abstract class LambdaLift extends InfoTransform {
 
     private def enclMethOrClass(sym: Symbol): Symbol = {
       def localToConstr(sym: Symbol) =
-	if (sym.isLocalDummy) sym.owner.primaryConstructor else sym;
-      var encl = localToConstr(sym);
+        if (sym.isLocalDummy) sym.owner.primaryConstructor else sym;
+      var encl = localToConstr(sym)
       while (!encl.isMethod && !encl.isClass)
         encl = localToConstr(outer(encl));
       encl
@@ -89,18 +90,18 @@ abstract class LambdaLift extends InfoTransform {
      *  pre: sym.isLocal, (owner.isMethod || owner.isClass)
      */
     private def markFree(sym: Symbol, owner: Symbol): boolean = {
-      if (settings.debug.value) log("mark " + sym + " of " + sym.owner + " free in " + owner);
+      if (settings.debug.value) log("mark " + sym + " of " + sym.owner + " free in " + owner)
       if (owner == enclMethOrClass(sym.owner)) true
       else if (owner.isPackageClass || !markFree(sym, enclMethOrClass(outer(owner)))) false
       else {
-	val ss = symSet(free, owner);
-	if (!(ss contains sym)) {
-	  ss addEntry sym;
-	  renamable addEntry sym;
-	  changedFreeVars = true;
-	  if (settings.debug.value) log("" + sym + " is free in " + owner);
-	  if (sym.isVariable && !(sym hasFlag CAPTURED)) {
-            sym setFlag CAPTURED;
+        val ss = symSet(free, owner)
+        if (!(ss contains sym)) {
+          ss addEntry sym;
+          renamable addEntry sym;
+          changedFreeVars = true
+          if (settings.debug.value) log("" + sym + " is free in " + owner);
+          if (sym.isVariable && !(sym hasFlag CAPTURED)) {
+            sym setFlag CAPTURED
             val symClass = sym.tpe.symbol;
             atPhase(phase.next) {
               sym updateInfo (
@@ -108,25 +109,25 @@ abstract class LambdaLift extends InfoTransform {
             }
           }
         }
-	!owner.isClass
+        !owner.isClass
       }
     }
 
     private def markCalled(sym: Symbol, owner: Symbol): unit = {
-      if (settings.debug.value) log("mark " + sym + " of " + sym.owner + " called by " + owner);
-      symSet(called, owner) addEntry sym;
+      if (settings.debug.value)
+        log("mark " + sym + " of " + sym.owner + " called by " + owner);
+      symSet(called, owner) addEntry sym
     }
 /*
-
       if (owner == enclMethOrClass(sym.owner)) true
       else if (owner.isPackageClass || !markCalled(sym, enclMethOrClass(outer(owner)))) false
       else {
-	val ss = symSet(called, owner);
-	if (!(ss contains sym)) {
-	  ss addEntry sym;
-	  if (settings.debug.value) log("" + sym + " is called by " + owner);
+        val ss = symSet(called, owner);
+        if (!(ss contains sym)) {
+          ss addEntry sym;
+          if (settings.debug.value) log("" + sym + " is called by " + owner);
         }
-	!owner.isClass
+        !owner.isClass
       }
     }
 */
@@ -141,37 +142,37 @@ abstract class LambdaLift extends InfoTransform {
        try { //debug
         val sym = tree.symbol;
         tree match {
-	  case ClassDef(_, _, _, _, _) =>
-            liftedDefs(tree.symbol) = new ListBuffer;
-	    if (sym.isLocal) renamable addEntry sym;
-	  case DefDef(_, _, _, _, _, _) =>
-	    if (sym.isLocal) {
-	      renamable addEntry sym;
-	      sym setFlag (PRIVATE | LOCAL | FINAL)
-	    } else if (sym.isPrimaryConstructor) {
-	      symSet(called, sym) addEntry sym.owner
-	    }
-	  case Ident(name) =>
-	    if (sym == NoSymbol) {
-	      assert(name == nme.WILDCARD)
+          case ClassDef(_, _, _, _, _) =>
+            liftedDefs(tree.symbol) = new ListBuffer
+            if (sym.isLocal) renamable addEntry sym
+          case DefDef(_, _, _, _, _, _) =>
+            if (sym.isLocal) {
+              renamable addEntry sym;
+              sym setFlag (PRIVATE | LOCAL | FINAL)
+            } else if (sym.isPrimaryConstructor) {
+              symSet(called, sym) addEntry sym.owner
+            }
+          case Ident(name) =>
+            if (sym == NoSymbol) {
+              assert(name == nme.WILDCARD)
             } else if (sym.isLocal) {
-	      val owner = enclMethOrClass(currentOwner);
+              val owner = enclMethOrClass(currentOwner);
               if (sym.isTerm && !sym.isMethod) markFree(sym, owner)
               else if (sym.isMethod) markCalled(sym, owner)
                 //symSet(called, owner) addEntry sym;
             }
-	  case Select(_, _) =>
+          case Select(_, _) =>
             if (sym.isConstructor && sym.owner.isLocal) {
-	      val owner = enclMethOrClass(currentOwner);
+              val owner = enclMethOrClass(currentOwner);
               markCalled(sym, owner) //symSet(called, owner) addEntry sym;
             }
           case _ =>
         }
         super.traverse(tree)
        } catch {//debug
-	 case ex: Throwable =>
-	   System.out.println("exception when traversing " + tree);
-	 throw ex
+         case ex: Throwable =>
+           System.out.println("exception when traversing " + tree);
+           throw ex
        }
       }
     }
@@ -182,14 +183,14 @@ abstract class LambdaLift extends InfoTransform {
      *  all class/function symbols that are owned by some function.
      */
     private def computeFreeVars: unit = {
-      freeVarTraverser.traverse(unit.body);
+      freeVarTraverser.traverse(unit.body)
 
       do {
-	changedFreeVars = false;
-	for (val caller <- called.keys;
-	     val callee <- called(caller).elements;
-	     val fv <- freeVars(callee))
-	  markFree(fv, caller);
+        changedFreeVars = false
+        for (val caller <- called.keys;
+             val callee <- called(caller).elements;
+             val fv <- freeVars(callee))
+          markFree(fv, caller);
       } while (changedFreeVars);
 
       for (val sym <- renamable.elements) {
@@ -216,7 +217,9 @@ abstract class LambdaLift extends InfoTransform {
 
     private def proxy(sym: Symbol) = {
       def searchIn(owner: Symbol): Symbol = {
-        if (settings.debug.value) log("searching for " + sym + "(" + sym.owner + ") in " + owner  + " " + enclMethOrClass(owner));//debug
+        if (settings.debug.value)
+          log("searching for " + sym + "(" + sym.owner + ") in " + owner +
+              " " + enclMethOrClass(owner));//debug
         proxies.get(enclMethOrClass(owner)) match {
           case Some(ps) =>
             ps filter (p => p.name == sym.name) match {
@@ -226,19 +229,21 @@ abstract class LambdaLift extends InfoTransform {
           case None => searchIn(outer(owner))
         }
       }
-      if (settings.debug.value) log("proxy " + sym + " in " + sym.owner + " from " + currentOwner.ownerChain + " " + enclMethOrClass(sym.owner));//debug
+      if (settings.debug.value)
+        log("proxy " + sym + " in " + sym.owner + " from " + currentOwner.ownerChain +
+            " " + enclMethOrClass(sym.owner));//debug
       if (enclMethOrClass(sym.owner) == enclMethOrClass(currentOwner)) sym
       else searchIn(currentOwner)
     }
 
     private def memberRef(sym: Symbol) = {
-      val clazz = sym.owner.enclClass;
+      val clazz = sym.owner.enclClass
       val qual = if (clazz == currentOwner.enclClass) gen.This(clazz)
-		 else {
-		   sym resetFlag(LOCAL | PRIVATE);
-		   if (clazz.isStaticOwner) gen.mkQualifier(clazz.thisType)
-		   else outerPath(outerValue, clazz)
-		 }
+                 else {
+                   sym resetFlag(LOCAL | PRIVATE)
+                   if (clazz.isStaticOwner) gen.mkQualifier(clazz.thisType)
+                   else outerPath(outerValue, clazz)
+                 }
       Select(qual, sym) setType sym.tpe
     }
 
@@ -252,8 +257,8 @@ abstract class LambdaLift extends InfoTransform {
     }
 
     private def addFreeArgs(pos: int, sym: Symbol, args: List[Tree]) = {
-      def freeArg(fv: Symbol) = atPos(pos)(proxyRef(fv));
-      val fvs = freeVars(sym).toList;
+      def freeArg(fv: Symbol) = atPos(pos)(proxyRef(fv))
+      val fvs = freeVars(sym).toList
       if (fvs.isEmpty) args else args ::: (fvs map freeArg)
     }
 
@@ -263,7 +268,7 @@ abstract class LambdaLift extends InfoTransform {
         tree match {
           case DefDef(mods, name, tparams, List(vparams), tpt, rhs) =>
             sym.updateInfo(
-	      lifted(MethodType(sym.info.paramTypes ::: (ps map (.tpe)), sym.info.resultType)));
+              lifted(MethodType(sym.info.paramTypes ::: (ps map (.tpe)), sym.info.resultType)));
             copy.DefDef(tree, mods, name, tparams, List(vparams ::: freeParams), tpt, rhs)
           case ClassDef(mods, name, tparams, tpt, impl @ Template(parents, body)) =>
             copy.ClassDef(tree, mods, name, tparams, tpt,
@@ -274,28 +279,28 @@ abstract class LambdaLift extends InfoTransform {
     }
 
     private def liftDef(tree: Tree): Tree = {
-      val sym = tree.symbol;
-      sym.owner = sym.owner.enclClass;
-      if (sym.isClass) sym.owner = sym.owner.toInterface;
-      if (sym.isMethod) sym setFlag LIFTED;
-      liftedDefs(sym.owner) += tree;
-      sym.owner.info.decls enterUnique sym;
-      if (settings.debug.value) log("lifted: " + sym + sym.locationString);
+      val sym = tree.symbol
+      sym.owner = sym.owner.enclClass
+      if (sym.isClass) sym.owner = sym.owner.toInterface
+      if (sym.isMethod) sym setFlag LIFTED
+      liftedDefs(sym.owner) += tree
+      sym.owner.info.decls enterUnique sym
+      if (settings.debug.value) log("lifted: " + sym + sym.locationString)
       EmptyTree
     }
 
     private def postTransform(tree: Tree): Tree = {
-      val sym = tree.symbol;
+      val sym = tree.symbol
       tree match {
         case ClassDef(_, _, _, _, _) =>
-          val tree1 = addFreeParams(tree, sym);
+          val tree1 = addFreeParams(tree, sym)
           if (sym.isLocal) liftDef(tree1) else tree1
-	case DefDef(_, _, _, _, _, _) =>
-          val tree1 = addFreeParams(tree, sym);
+        case DefDef(_, _, _, _, _, _) =>
+          val tree1 = addFreeParams(tree, sym)
           if (sym.isLocal) liftDef(tree1) else tree1
-	case ValDef(mods, name, tpt, rhs) =>
+        case ValDef(mods, name, tpt, rhs) =>
           if (sym.isCapturedVariable) {
-            val tpt1 = TypeTree(sym.tpe) setPos tpt.pos;
+            val tpt1 = TypeTree(sym.tpe) setPos tpt.pos
             val rhs1 =
               atPos(rhs.pos) {
                 typed {
@@ -306,28 +311,28 @@ abstract class LambdaLift extends InfoTransform {
           } else tree
         case Return(Block(stats, value)) =>
           Block(stats, copy.Return(tree, value)) setType tree.tpe setPos tree.pos
-	case Return(expr) =>
-	  assert(sym == currentOwner.enclMethod, sym)
+        case Return(expr) =>
+          assert(sym == currentOwner.enclMethod, sym)
           tree
-	case Apply(fn, args) =>
-	  copy.Apply(tree, fn, addFreeArgs(tree.pos, sym, args));
-	case Assign(Apply(TypeApply(sel @ Select(qual, _), _), List()), rhs) =>
-	  // eliminate casts introduced by selecting a captured variable field
-	  // on the lhs of an assignment.
-	  assert(sel.symbol == Object_asInstanceOf);
-	  copy.Assign(tree, qual, rhs)
+        case Apply(fn, args) =>
+          copy.Apply(tree, fn, addFreeArgs(tree.pos, sym, args))
+        case Assign(Apply(TypeApply(sel @ Select(qual, _), _), List()), rhs) =>
+          // eliminate casts introduced by selecting a captured variable field
+          // on the lhs of an assignment.
+          assert(sel.symbol == Object_asInstanceOf)
+          copy.Assign(tree, qual, rhs)
         case Ident(name) =>
-	  val tree1 =
+          val tree1 =
             if (sym != NoSymbol && sym.isTerm && !sym.isLabel)
-	      if (sym.isMethod)
-		atPos(tree.pos)(memberRef(sym))
-	      else if (sym.isLocal && enclMethOrClass(sym.owner) != enclMethOrClass(currentOwner))
-		atPos(tree.pos)(proxyRef(sym))
-	      else tree
-	    else tree;
+              if (sym.isMethod)
+                atPos(tree.pos)(memberRef(sym))
+              else if (sym.isLocal && enclMethOrClass(sym.owner) != enclMethOrClass(currentOwner))
+                atPos(tree.pos)(proxyRef(sym))
+              else tree
+            else tree;
           if (sym.isCapturedVariable)
             atPos(tree.pos) {
-              val tp = tree.tpe;
+              val tp = tree.tpe
               val elemTree = typed { Select(tree1 setType sym.tpe, nme.elem) }
               if (elemTree.tpe.symbol != tp.symbol) gen.cast(elemTree, tp) else elemTree
             }
@@ -338,27 +343,28 @@ abstract class LambdaLift extends InfoTransform {
     }
 
     override def transform(tree: Tree): Tree = {
-      postTransform(super.transform(tree) setType lifted(tree.tpe));
+      postTransform(super.transform(tree) setType lifted(tree.tpe))
     }
     /** Transform statements and add lifted definitions to them. */
     override def transformStats(stats: List[Tree], exprOwner: Symbol): List[Tree] = {
       def addLifted(stat: Tree): Tree = stat match {
-	case ClassDef(mods, name, tparams, tpt, impl @ Template(parents, body)) =>
-	  val lifted = liftedDefs(stat.symbol).toList map addLifted;
-	  val result = copy.ClassDef(
+        case ClassDef(mods, name, tparams, tpt, impl @ Template(parents, body)) =>
+          val lifted = liftedDefs(stat.symbol).toList map addLifted
+          val result = copy.ClassDef(
             stat, mods, name, tparams, tpt, copy.Template(impl, parents, body ::: lifted));
-	  liftedDefs -= stat.symbol;
-	  result
-	case _ =>
-	  stat
+          liftedDefs -= stat.symbol;
+          result
+        case _ =>
+          stat
       }
       super.transformStats(stats, exprOwner) map addLifted
     }
 
     override def transformUnit(unit: CompilationUnit): unit = {
-      computeFreeVars;
-      atPhase(phase.next)(super.transformUnit(unit));
+      computeFreeVars
+      atPhase(phase.next)(super.transformUnit(unit))
       assert(liftedDefs.size == 0, liftedDefs.keys.toList)
     }
-  }
+  } // class LambdaLifter
+
 }