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

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

1 files changed, 75 insertions, 73 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
index a2dc990e67..a7df6449dd 100644
--- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
@@ -1,38 +1,39 @@
-/* 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 symtab._;
-import Flags._;
-import collection.mutable.{HashMap, ListBuffer};
+package scala.tools.nsc.transform
+
+import symtab._
+import Flags._
+import collection.mutable.{HashMap, ListBuffer}
 
 abstract class AddInterfaces extends InfoTransform {
-  import global._;                  // the global environment
-  import definitions._;             // standard classes and methods
-  import posAssigner.atPos;         // for filling in tree positions
+  import global._                  // the global environment
+  import definitions._             // standard classes and methods
+  import posAssigner.atPos         // for filling in tree positions
 
-  override def phaseNewFlags: long = lateDEFERRED | lateINTERFACE;
+  override def phaseNewFlags: long = lateDEFERRED | lateINTERFACE
 
 // Type transformation
 
-  def erasedTypeRef(sym: Symbol): Type;
+  def erasedTypeRef(sym: Symbol): Type
 
-  private val implClassMap = new HashMap[Symbol, Symbol];
-  private val implMethodMap = new HashMap[Symbol, Symbol];
+  private val implClassMap = new HashMap[Symbol, Symbol]
+  private val implMethodMap = new HashMap[Symbol, Symbol]
 
   override def newPhase(prev: scala.tools.nsc.Phase): StdPhase = {
-    implClassMap.clear;
-    implMethodMap.clear;
+    implClassMap.clear
+    implMethodMap.clear
     super.newPhase(prev)
   }
 
   private def needsImplMethod(sym: Symbol): boolean = (
     sym.isMethod && isInterfaceMember(sym) &&
     (!(sym hasFlag (DEFERRED | SUPERACCESSOR)) || (sym hasFlag lateDEFERRED))
-  );
+  )
 
   private def isInterfaceMember(sym: Symbol): boolean = {
     sym.info; // to set lateMETHOD flag if necessary
@@ -45,19 +46,19 @@ abstract class AddInterfaces extends InfoTransform {
     case Some(c) => c
     case None =>
       atPhase(currentRun.erasurePhase) {
-        val implName = nme.implClassName(iface.name);
-        var impl = if (iface.owner.isClass) iface.owner.info.decl(implName) else NoSymbol;
+        val implName = nme.implClassName(iface.name)
+        var impl = if (iface.owner.isClass) iface.owner.info.decl(implName) else NoSymbol
         if (impl == NoSymbol) {
-          impl = iface.cloneSymbolImpl(iface.owner);
-          impl.name = implName;
+          impl = iface.cloneSymbolImpl(iface.owner)
+          impl.name = implName
           if (iface.owner.isClass) iface.owner.info.decls enter impl
         }
-        if (currentRun.compiles(iface)) currentRun.symSource(impl) = iface.sourceFile;
-        impl setPos iface.pos;
-        impl.flags = iface.flags & ~(INTERFACE | lateINTERFACE) | IMPLCLASS;
-	impl setInfo new LazyImplClassType(iface);
-        implClassMap(iface) = impl;
-        if (settings.debug.value) log("generating impl class " + impl + " in " + iface.owner);//debug
+        if (currentRun.compiles(iface)) currentRun.symSource(impl) = iface.sourceFile
+        impl setPos iface.pos
+        impl.flags = iface.flags & ~(INTERFACE | lateINTERFACE) | IMPLCLASS
+        impl setInfo new LazyImplClassType(iface)
+        implClassMap(iface) = impl
+        if (settings.debug.value) log("generating impl class " + impl + " in " + iface.owner)//debug
         impl
       }
   }
@@ -65,35 +66,35 @@ abstract class AddInterfaces extends InfoTransform {
   private class LazyImplClassType(iface: Symbol) extends LazyType {
 
     def implDecls(implClass: Symbol, ifaceDecls: Scope): Scope = {
-      val decls = new Scope();
+      val decls = new Scope()
       for (val sym <- ifaceDecls.elements) {
         if (isInterfaceMember(sym)) {
           if (needsImplMethod(sym)) {
-	    val impl = sym.cloneSymbol(implClass).setInfo(sym.info).resetFlag(lateDEFERRED);
-	    if (currentRun.compiles(implClass)) implMethodMap(sym) = impl;
-	    decls enter impl;
-	    sym setFlag lateDEFERRED
+            val impl = sym.cloneSymbol(implClass).setInfo(sym.info).resetFlag(lateDEFERRED)
+            if (currentRun.compiles(implClass)) implMethodMap(sym) = impl
+            decls enter impl
+            sym setFlag lateDEFERRED
           }
         } else {
-	  sym.owner = implClass;
-          decls enter sym;
-	}
+          sym.owner = implClass
+          decls enter sym
+        }
       }
       decls
     }
 
     override def complete(sym: Symbol): unit = {
       def implType(tp: Type): Type = tp match {
-	case ClassInfoType(parents, decls, _) =>
-	  //ClassInfoType(mixinToImplClass(parents) ::: List(iface.tpe), implDecls(sym, decls), sym)
-	  ClassInfoType(
+        case ClassInfoType(parents, decls, _) =>
+          //ClassInfoType(mixinToImplClass(parents) ::: List(iface.tpe), implDecls(sym, decls), sym)
+          ClassInfoType(
             ObjectClass.tpe :: (parents.tail map mixinToImplClass) ::: List(iface.tpe),
             implDecls(sym, decls),
             sym)
-	case PolyType(tparams, restpe) =>
-	  PolyType(tparams, implType(restpe))
+        case PolyType(tparams, restpe) =>
+          PolyType(tparams, implType(restpe))
       }
-      sym.setInfo(atPhase(currentRun.erasurePhase)(implType(iface.info)));
+      sym.setInfo(atPhase(currentRun.erasurePhase)(implType(iface.info)))
     }
 
     override def load(clazz: Symbol): unit = complete(clazz)
@@ -109,7 +110,7 @@ abstract class AddInterfaces extends InfoTransform {
   def transformMixinInfo(tp: Type): Type = tp match {
     case ClassInfoType(parents, decls, clazz) =>
       if (clazz.needsImplClass) {
-        clazz setFlag lateINTERFACE;
+        clazz setFlag lateINTERFACE
         implClass(clazz) // generate an impl class
       }
       val parents1 =
@@ -118,10 +119,11 @@ abstract class AddInterfaces extends InfoTransform {
           assert(!parents.head.symbol.isTrait || clazz == RepeatedParamClass, clazz);
           if (clazz hasFlag INTERFACE) erasedTypeRef(ObjectClass) :: parents.tail
           else if (clazz.isImplClass || clazz == ArrayClass) parents
-	  else parents map mixinToImplClass
+          else parents map mixinToImplClass
         }
       val decls1 = decls filter (sym =>
-        if (clazz hasFlag INTERFACE) isInterfaceMember(sym) else (!sym.isType || sym.isClass))
+        if (clazz hasFlag INTERFACE) isInterfaceMember(sym)
+        else (!sym.isType || sym.isClass))
 
       //if (!clazz.isPackageClass) System.out.println("Decls of "+clazz+" after explicitOuter = " + decls1);//DEBUG
       if ((parents1 eq parents) && (decls1 eq decls)) tp
@@ -137,7 +139,7 @@ abstract class AddInterfaces extends InfoTransform {
     override def traverse(tree: Tree): unit = {
       tree match {
         case Return(expr) =>
-          if (tree.symbol == oldowner) tree.symbol = newowner;
+          if (tree.symbol == oldowner) tree.symbol = newowner
         case _ =>
       }
       super.traverse(tree)
@@ -175,16 +177,16 @@ abstract class AddInterfaces extends InfoTransform {
   }
 
   def implClassDefs(trees: List[Tree]): List[Tree] = {
-    val buf = new ListBuffer[Tree];
+    val buf = new ListBuffer[Tree]
     for (val tree <- trees)
       tree match {
-	case ClassDef(_, _, _, _, impl) =>
-	  if (tree.symbol.needsImplClass)
+        case ClassDef(_, _, _, _, impl) =>
+          if (tree.symbol.needsImplClass)
             buf += {
               val clazz = implClass(tree.symbol).initialize;
               ClassDef(clazz, implTemplate(clazz, impl))
             }
-	case _ =>
+        case _ =>
       }
     buf.toList
   }
@@ -192,41 +194,41 @@ abstract class AddInterfaces extends InfoTransform {
   protected val mixinTransformer = new Transformer {
     override def transformStats(stats: List[Tree], exprOwner: Symbol): List[Tree] =
       (super.transformStats(stats, exprOwner) :::
-       super.transformStats(implClassDefs(stats), exprOwner));
+       super.transformStats(implClassDefs(stats), exprOwner))
     override def transform(tree: Tree): Tree = {
       val tree1 = tree match {
-	case ClassDef(mods, name, tparams, tpt, impl) =>
-	  if (tree.symbol.needsImplClass) {
-            implClass(tree.symbol).initialize; // to force lateDEFERRED flags
-	    copy.ClassDef(tree, mods | INTERFACE, name, tparams, tpt, ifaceTemplate(impl))
+        case ClassDef(mods, name, tparams, tpt, impl) =>
+          if (tree.symbol.needsImplClass) {
+            implClass(tree.symbol).initialize // to force lateDEFERRED flags
+            copy.ClassDef(tree, mods | INTERFACE, name, tparams, tpt, ifaceTemplate(impl))
           }
-	  else tree
-	case Template(parents, body) =>
+          else tree
+        case Template(parents, body) =>
           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) {
-            val impl = implClass(tree.symbol);
-            var owner = currentOwner;
+        case This(_) =>
+          if (tree.symbol.needsImplClass) {
+            val impl = implClass(tree.symbol)
+            var owner = currentOwner
             while (owner != tree.symbol && owner != impl) owner = owner.owner;
             if (owner == impl) This(impl) setPos tree.pos
             else tree
           } else tree
-	case Super(qual, mix) =>
-	  val mix1 =
-	    if (mix == nme.EMPTY.toTypeName) mix
-	    else {
-	      val ps = atPhase(currentRun.erasurePhase) {
+        case Super(qual, mix) =>
+          val mix1 =
+            if (mix == nme.EMPTY.toTypeName) mix
+            else {
+              val ps = atPhase(currentRun.erasurePhase) {
                 tree.symbol.info.parents dropWhile (p => p.symbol.name != mix)
               }
-	      assert(!ps.isEmpty, tree);
-	      if (ps.head.symbol.needsImplClass) implClass(ps.head.symbol).name
-	      else mix
-	    }
-	  if (tree.symbol.needsImplClass) Super(implClass(tree.symbol), mix1) setPos tree.pos
-	  else copy.Super(tree, qual, mix1)
-	case _ =>
-	  tree
+              assert(!ps.isEmpty, tree);
+              if (ps.head.symbol.needsImplClass) implClass(ps.head.symbol).name
+              else mix
+            }
+          if (tree.symbol.needsImplClass) Super(implClass(tree.symbol), mix1) setPos tree.pos
+          else copy.Super(tree, qual, mix1)
+        case _ =>
+          tree
       }
       super.transform(tree1)
     }