removed leading/trailing tabs/blanks in transfo...

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

4 files changed, 61 insertions, 53 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
index d07c56cfcf..24bf59a7fe 100644
--- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
@@ -149,15 +149,15 @@ abstract class AddInterfaces extends InfoTransform {
   private def ifaceMemberDef(tree: Tree): Tree =
     if (!tree.isDef || !isInterfaceMember(tree.symbol)) EmptyTree
     else if (needsImplMethod(tree.symbol)) DefDef(tree.symbol, vparamss => EmptyTree)
-    else tree;
+    else tree
 
   private def ifaceTemplate(templ: Template): Template =
-    copy.Template(templ, templ.parents, templ.body map ifaceMemberDef);
+    copy.Template(templ, templ.parents, templ.body map ifaceMemberDef)
 
   private def implMethodDef(tree: Tree, ifaceMethod: Symbol): Tree =
     implMethodMap.get(ifaceMethod) match {
       case Some(implMethod) =>
-        tree.symbol = implMethod;
+        tree.symbol = implMethod
         new ChangeOwnerAndReturnTraverser(ifaceMethod, implMethod)(tree)
       case None =>
         throw new Error("implMethod missing for " + ifaceMethod)
@@ -166,9 +166,9 @@ abstract class AddInterfaces extends InfoTransform {
   private def implMemberDef(tree: Tree): Tree =
     if (!tree.isDef || !isInterfaceMember(tree.symbol)) tree
     else if (needsImplMethod(tree.symbol)) implMethodDef(tree, tree.symbol)
-    else EmptyTree;
+    else EmptyTree
 
-  private def implTemplate(clazz: Symbol, templ: Template): Template = atPos(templ.pos){
+  private def implTemplate(clazz: Symbol, templ: Template): Template = atPos(templ.pos) {
     val templ1 = Template(templ.parents, templ.body map implMemberDef)
       .setPos(templ.pos)
       .setSymbol(clazz.newLocalDummy(templ.pos));
@@ -183,7 +183,7 @@ abstract class AddInterfaces extends InfoTransform {
         case ClassDef(_, _, _, _, impl) =>
           if (tree.symbol.needsImplClass)
             buf += {
-              val clazz = implClass(tree.symbol).initialize;
+              val clazz = implClass(tree.symbol).initialize
               ClassDef(clazz, implTemplate(clazz, impl))
             }
         case _ =>
@@ -204,7 +204,7 @@ abstract class AddInterfaces extends InfoTransform {
           }
           else tree
         case Template(parents, body) =>
-          val parents1 = tree.symbol.owner.info.parents map (t => TypeTree(t) setPos tree.pos);
+          val parents1 = tree.symbol.owner.info.parents map (t => TypeTree(t) setPos tree.pos)
           copy.Template(tree, parents1, body)
         case This(_) =>
           if (tree.symbol.needsImplClass) {
@@ -240,18 +240,18 @@ abstract class AddInterfaces extends InfoTransform {
         if (sym.hasFlag(PRIVATE)) {
           var o = currentOwner;
           while (o != NoSymbol && o != sym.owner && !o.isLocal && !o.hasFlag(PRIVATE))
-          o = o.owner;
+          o = o.owner
           if (o == sym.owner) sym.makeNotPrivate(base);
         }
       }
       def traverse(t: Type): TypeTraverser = {
         t match {
           case TypeRef(qual, sym, args) =>
-            ensureNoEscape(sym);
-            mapOver(t);
+            ensureNoEscape(sym)
+            mapOver(t)
           case ClassInfoType(parents, decls, clazz) =>
             parents foreach { p => traverse; () }
-            traverse(t.typeOfThis);
+            traverse(t.typeOfThis)
           case _ =>
             mapOver(t)
         }
diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
index be67c4cd26..65f78a0a2b 100644
--- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
@@ -45,7 +45,7 @@ abstract class ExplicitOuter extends InfoTransform {
       if (sym.owner.isTrait && (sym hasFlag PROTECTED)) sym setFlag notPROTECTED
       if (sym.isConstructor && !isStatic(sym.owner))
         MethodType(formals ::: List(outerClass(sym.owner).toInterface.thisType), restpe)
-      else tp;
+      else tp
     case ClassInfoType(parents, decls, clazz) =>
       var decls1 = decls
       if (!(clazz hasFlag INTERFACE)) {
@@ -59,7 +59,7 @@ abstract class ExplicitOuter extends InfoTransform {
                      setInfo MethodType(List(), outerClass(clazz).thisType));
           decls1 enter (clazz.newValue(clazz.pos, nme.getterToLocal(outerAcc.name))
             setFlag (LOCAL | PRIVATE | PARAMACCESSOR | (outerAcc getFlag EXPANDEDNAME))
-            setInfo outerClass(clazz).thisType);
+            setInfo outerClass(clazz).thisType)
         }
         if (clazz.isTrait) {
           decls1 = newScope(decls1.toList)
@@ -104,12 +104,12 @@ abstract class ExplicitOuter extends InfoTransform {
 
     /** The path
      *     `base'.$outer ... .$outer
-     *  which refers to the outer instance `to' of value `base
+     *  which refers to the outer instance 'to' of value 'base'
      */
     protected def outerPath(base: Tree, to: Symbol): Tree =
       if (base.tpe.symbol == to) base else outerPath(outerSelect(base), to)
 
-    /** Select and apply outer accessor from `base'
+    /** Select and apply outer accessor from 'base'
      */
     private def outerSelect(base: Tree): Tree = {
       val otp = outerClass(base.tpe.symbol).thisType
@@ -168,7 +168,7 @@ abstract class ExplicitOuter extends InfoTransform {
       var localTyper: analyzer.Typer = typer
 
       /** The two definitions
-       *    val outer : C.this.type _;
+       *    val outer: C.this.type _;
        *    def outer(): C.this.type  = outer ;
        *  Here, C is the class enclosing the class `clazz' containing the two definitions.
        */
@@ -226,9 +226,9 @@ abstract class ExplicitOuter extends InfoTransform {
           val ps = clazz.info.parents
           if (ps.isEmpty) List()
           else {
-            val superClass = ps.head.symbol;
+            val superClass = ps.head.symbol
             for {
-              val mclazz <- clazz.info.baseClasses.tail.takeWhile(superClass ne).reverse;
+              val mclazz <- clazz.info.baseClasses.tail.takeWhile(superClass ne).reverse
               mclazz.needsImplClass && mclazz != ScalaObjectClass
             } yield mixinConstructorCall(mclazz)
           }
@@ -257,7 +257,7 @@ abstract class ExplicitOuter extends InfoTransform {
           case Template(parents, decls) =>
             val savedLocalTyper = localTyper
             localTyper = localTyper.atOwner(tree, currentOwner)
-            var decls1 = decls;
+            var decls1 = decls
             if (!(currentOwner hasFlag INTERFACE) || (currentOwner hasFlag lateINTERFACE)) {
               if (!isStatic(currentOwner))
                 decls1 = decls1 ::: outerDefs(currentOwner); // (1)
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index cce643d926..1b9bf64dfd 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -137,14 +137,15 @@ abstract class LambdaLift extends InfoTransform {
      *  }
      */
     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;
+          ss addEntry sym
+          renamable addEntry sym
           changedFreeVars = true
           if (settings.debug.value) log("" + sym + " is free in " + owner);
           if (sym.isVariable && !(sym hasFlag CAPTURED)) {
@@ -194,7 +195,7 @@ abstract class LambdaLift extends InfoTransform {
             if (sym.isLocal) renamable addEntry sym
           case DefDef(_, _, _, _, _, _) =>
             if (sym.isLocal) {
-              renamable addEntry sym;
+              renamable addEntry sym
               sym setFlag (PRIVATE | LOCAL | FINAL)
             } else if (sym.isPrimaryConstructor) {
               symSet(called, sym) addEntry sym.owner
@@ -203,22 +204,22 @@ abstract class LambdaLift extends InfoTransform {
             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;
+                //symSet(called, owner) addEntry sym
             }
           case Select(_, _) =>
             if (sym.isConstructor && sym.owner.isLocal) {
               val owner = enclMethOrClass(currentOwner);
-              markCalled(sym, owner) //symSet(called, owner) addEntry sym;
+              markCalled(sym, owner) //symSet(called, owner) addEntry sym
             }
           case _ =>
         }
         super.traverse(tree)
        } catch {//debug
          case ex: Throwable =>
-           System.out.println("exception when traversing " + tree);
+           System.out.println("exception when traversing " + tree)
            throw ex
        }
       }
@@ -237,12 +238,12 @@ abstract class LambdaLift extends InfoTransform {
         for (val caller <- called.keys;
              val callee <- called(caller).elements;
              val fv <- freeVars(callee))
-          markFree(fv, caller);
+          markFree(fv, caller)
       } while (changedFreeVars);
 
       for (val sym <- renamable.elements) {
-        sym.name = unit.fresh.newName(sym.name.toString() + "$");
-        if (settings.debug.value) log("renamed: " + sym.name);
+        sym.name = unit.fresh.newName(sym.name.toString() + "$")
+        if (settings.debug.value) log("renamed: " + sym.name)
       }
 
       atPhase(phase.next) {
@@ -286,11 +287,11 @@ abstract class LambdaLift extends InfoTransform {
     private def memberRef(sym: Symbol) = {
       val clazz = sym.owner.enclClass
       val qual = if (clazz == currentOwner.enclClass) gen.mkAttributedThis(clazz)
-		 else {
-		   sym resetFlag(LOCAL | PRIVATE);
-		   if (clazz.isStaticOwner) gen.mkAttributedQualifier(clazz.thisType)
-		   else outerPath(outerValue, clazz)
-		 }
+                 else {
+                   sym resetFlag(LOCAL | PRIVATE)
+                   if (clazz.isStaticOwner) gen.mkAttributedQualifier(clazz.thisType)
+                   else outerPath(outerValue, clazz)
+                 }
       Select(qual, sym) setType sym.tpe
     }
 
@@ -298,7 +299,7 @@ abstract class LambdaLift extends InfoTransform {
       if (sym.owner.isLabel) //
         gen.mkAttributedIdent(sym)      // bq: account for the fact that LambdaLift does not know how to handle references to LabelDef parameters.
       else {                 //
-        val psym = proxy(sym);
+        val psym = proxy(sym)
         if (psym.isLocal) gen.mkAttributedIdent(psym) else memberRef(psym)
       }
     }
@@ -389,17 +390,17 @@ abstract class LambdaLift extends InfoTransform {
       }
     }
 
-    override def transform(tree: Tree): Tree = {
+    override def transform(tree: Tree): Tree =
       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(
-            stat, mods, name, tparams, tpt, copy.Template(impl, parents, body ::: lifted));
-          liftedDefs -= stat.symbol;
+            stat, mods, name, tparams, tpt, copy.Template(impl, parents, body ::: lifted))
+          liftedDefs -= stat.symbol
           result
         case _ =>
           stat
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index 74ebe4f00c..d4d3cd74d5 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -44,7 +44,9 @@ abstract class Mixin extends InfoTransform {
       var bcs = base.info.baseClasses.dropWhile(prevowner !=).tail
       assert(!bcs.isEmpty/*, "" + prevowner + " " + base.info.baseClasses*/)//DEBUG
       var sym: Symbol = NoSymbol
-      if (settings.debug.value) log("starting rebindsuper " + base + " " + member + ":" + member.tpe + " " + prevowner + " " + base.info.baseClasses);
+      if (settings.debug.value)
+        log("starting rebindsuper " + base + " " + member + ":" + member.tpe +
+            " " + prevowner + " " + base.info.baseClasses)
       while (!bcs.isEmpty && sym == NoSymbol) {
         if (settings.debug.value) {
           val other = bcs.head.info.nonPrivateDecl(member.name);
@@ -53,7 +55,7 @@ abstract class Mixin extends InfoTransform {
         sym = member.overridingSymbol(bcs.head).suchThat(sym => !sym.hasFlag(DEFERRED | BRIDGE))
         bcs = bcs.tail
       }
-      assert(sym != NoSymbol, member);
+      assert(sym != NoSymbol, member)
       sym
     }
 
@@ -103,11 +105,11 @@ abstract class Mixin extends InfoTransform {
       val superclazz = clazz.info.parents.head.symbol
       addMixedinMembers(superclazz)
       //System.out.println("adding members of " + clazz.info.baseClasses.tail.takeWhile(superclazz !=) + " to " + clazz);//DEBUG
-      val mixins = clazz.info.baseClasses.tail.takeWhile(superclazz !=);
+      val mixins = clazz.info.baseClasses.tail.takeWhile(superclazz !=)
       def mixinMembers(mixinClass: Symbol): unit = {
         //Console.println("mixin members of "+mixinClass+" to "+clazz+" "+clazz.info.baseClasses)//DEBUG
         if (mixinClass.isImplClass) {
-          addLateInterfaceMembers(mixinClass.toInterface);
+          addLateInterfaceMembers(mixinClass.toInterface)
           for (val member <- mixinClass.info.decls.toList) {
             if (isForwarded(member) && !member.isImplOnly) {
               val imember = member.overriddenSymbol(mixinClass.toInterface)
@@ -144,10 +146,10 @@ abstract class Mixin extends InfoTransform {
                               setInfo member.tpe.resultType)
                 }
             } else if (member hasFlag SUPERACCESSOR) {
-              val member1 = addMember(clazz, member.cloneSymbol(clazz)) setPos clazz.pos;
-              assert(member1.alias != NoSymbol, member1);
-              val alias1 = rebindSuper(clazz, member.alias, mixinClass);
-              member1.asInstanceOf[TermSymbol] setAlias alias1;
+              val member1 = addMember(clazz, member.cloneSymbol(clazz)) setPos clazz.pos
+              assert(member1.alias != NoSymbol, member1)
+              val alias1 = rebindSuper(clazz, member.alias, mixinClass)
+              member1.asInstanceOf[TermSymbol] setAlias alias1
             } else if (member.isMethod && member.isModule && !(member hasFlag (LIFTED | BRIDGE))) {
               addMember(clazz, member.cloneSymbol(clazz))
                 .setPos(clazz.pos)
@@ -191,7 +193,7 @@ abstract class Mixin extends InfoTransform {
       }
       //decls1 = atPhase(phase.next)(newScope(decls1.toList))//debug
       if ((parents1 eq parents) && (decls1 eq decls)) tp
-      else ClassInfoType(parents1, decls1, clazz);
+      else ClassInfoType(parents1, decls1, clazz)
 
     case MethodType(formals, restp) =>
       toInterfaceMap(
@@ -202,7 +204,8 @@ abstract class Mixin extends InfoTransform {
       tp
   }
 
-  protected def newTransformer(unit: CompilationUnit): Transformer = new MixinTransformer;
+  protected def newTransformer(unit: CompilationUnit): Transformer =
+    new MixinTransformer
 
   class MixinTransformer extends Transformer {
     private var self: Symbol = _
@@ -252,7 +255,8 @@ abstract class Mixin extends InfoTransform {
       sym.owner.info
       sym.owner.owner.info
       if (sym.owner.sourceModule == NoSymbol) {
-        assert(false, "" + sym + " in " + sym.owner + " in " + sym.owner.owner + " " + sym.owner.owner.info.decls.toList)//debug
+        assert(false, "" + sym + " in " + sym.owner + " in " + sym.owner.owner +
+                      " " + sym.owner.owner.info.decls.toList)//debug
       }
       Select(gen.mkAttributedRef(sym.owner.sourceModule), sym)
     }
@@ -290,7 +294,10 @@ abstract class Mixin extends InfoTransform {
                   vparams map (vparam => Ident(vparam.symbol)));
           val rhs1 = localTyper.typed(atPos(stat.pos)(rhs0), stat.symbol.tpe.resultType);
           val rhs2 = atPhase(currentRun.mixinPhase)(transform(rhs1))
-          if (settings.debug.value) log("complete super acc " + stat.symbol + stat.symbol.locationString + " " + rhs1 + " " + stat.symbol.alias + stat.symbol.alias.locationString + "/" + stat.symbol.alias.owner.hasFlag(lateINTERFACE))//debug
+          if (settings.debug.value)
+            log("complete super acc " + stat.symbol + stat.symbol.locationString +
+                " " + rhs1 + " " + stat.symbol.alias + stat.symbol.alias.locationString +
+                "/" + stat.symbol.alias.owner.hasFlag(lateINTERFACE))//debug
           copy.DefDef(stat, mods, name, tparams, List(vparams), tpt, rhs2)
         case _ =>
           stat
@@ -328,7 +335,7 @@ abstract class Mixin extends InfoTransform {
                 }
                 if (sym.isSetter) Assign(accessedRef, Ident(vparams.head)) else accessedRef})
             } else if (sym.isModule && !(sym hasFlag LIFTED)) {
-              val vdef = gen.mkModuleVarDef(sym);
+              val vdef = gen.mkModuleVarDef(sym)
               addDef(position(sym), vdef)
               addDef(position(sym), gen.mkModuleAccessDef(sym, vdef.symbol))
             } else if (!sym.isMethod) {