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

removed leading/trailing tabs/blanks in typechecker/TreeCheckers.scala

1 files changed, 70 insertions, 68 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
index 5b5fc31e5b..f48f6eaf96 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
@@ -1,69 +1,71 @@
-/* NSC -- new scala compiler
- * Copyright 2005 LAMP/EPFL
+/* NSC -- new Scala compiler
+ * Copyright 2005-2006 LAMP/EPFL
  * @author  Martin Odersky
  */
 // $Id$
-package scala.tools.nsc.typechecker;
 
-import scala.tools.nsc.util.Position;
-import scala.tools.nsc.reporters.AbstractReporter;
-import symtab.Flags._;
+package scala.tools.nsc.typechecker
+
+import scala.tools.nsc.reporters.AbstractReporter
+import scala.tools.nsc.symtab.Flags._
+import scala.tools.nsc.util.Position
 
 abstract class TreeCheckers extends Analyzer {
 
-  import global._;
+  import global._
 
-  val tpeOfTree = new scala.collection.mutable.HashMap[Tree, Type];
+  val tpeOfTree = new scala.collection.mutable.HashMap[Tree, Type]
 
   def checkTrees: unit = {
-    System.out.println("[consistency check at start of phase " + phase + "]");
-    for (val unit <- currentRun.units) check(unit);
+    System.out.println("[consistency check at start of phase " + phase + "]")
+    for (val unit <- currentRun.units) check(unit)
   }
 
   def check(unit: CompilationUnit): unit = {
-    val areporter = if (reporter.isInstanceOf[AbstractReporter]) reporter.asInstanceOf[AbstractReporter] else null;
+    val areporter =
+      if (reporter.isInstanceOf[AbstractReporter]) reporter.asInstanceOf[AbstractReporter]
+      else null
 
     val curPrompt = if (areporter != null) {
-      val ret = areporter.prompt;
-      areporter.prompt = true;
-      ret;
-    } else false;
+      val ret = areporter.prompt
+      areporter.prompt = true
+      ret
+    } else false
 
-    val context = rootContext(unit);
-    context.checking = true;
-    tpeOfTree.clear;
-    val checker = new TreeChecker(context);
-    checker.precheck.traverse(unit.body);
-    checker.typed(unit.body);
-    checker.postcheck.traverse(unit.body);
+    val context = rootContext(unit)
+    context.checking = true
+    tpeOfTree.clear
+    val checker = new TreeChecker(context)
+    checker.precheck.traverse(unit.body)
+    checker.typed(unit.body)
+    checker.postcheck.traverse(unit.body)
     if (areporter != null)
-      areporter.prompt = curPrompt;
+      areporter.prompt = curPrompt
   }
 
-  override def newTyper(context: Context): Typer = new TreeChecker(context);
+  override def newTyper(context: Context): Typer = new TreeChecker(context)
 
   class TreeChecker(context0: Context) extends Typer(context0) {
 
-    import infer._;
+    import infer._
 
     override def typed(tree: Tree, mode: int, pt: Type): Tree = {
-      //System.out.println("**** checking " + tree);//debug
       tree match {
-	case EmptyTree | TypeTree() =>
-	  ;
-	case _ =>
-	  if (!tpeOfTree.contains(tree)) {
-	    tpeOfTree.update(tree, tree.tpe);
+        case EmptyTree | TypeTree() =>
+          ;
+        case _ =>
+          if (!tpeOfTree.contains(tree)) {
+            tpeOfTree.update(tree, tree.tpe)
             tree.tpe = null
-	  }
+          }
           val newtree = super.typed(tree, mode, pt);
           if ((newtree ne tree) && !newtree.isInstanceOf[Literal])
-            error(tree.pos, "trees differ\n old: " + tree + " [" + tree.getClass() + "]\n new: " +
-		  newtree + " [" + newtree.getClass() + "]");
+            error(tree.pos, "trees differ\n old: " + tree + " [" + tree.getClass() +
+                  "]\n new: " + newtree + " [" + newtree.getClass() + "]")
       }
       tree
     }
-    override def typed(tree: Tree) = super.typed(tree); // doto remove for new compiler
+    override def typed(tree: Tree) = super.typed(tree) // TODO: remove for new compiler
 
     object precheck extends Traverser {
       override def traverse(tree: Tree): unit =
@@ -71,11 +73,11 @@ abstract class TreeCheckers extends Analyzer {
           tree match {
             case DefDef(_, _, _, _, _, _) =>
               if (tree.symbol.hasFlag(ACCESSOR) &&
-		  !tree.symbol.hasFlag(DEFERRED) &&
-		  !tree.symbol.tpe.resultType.isInstanceOf[ConstantType]) {
-                assert(tree.symbol.accessed != NoSymbol);
+                  !tree.symbol.hasFlag(DEFERRED) &&
+                  !tree.symbol.tpe.resultType.isInstanceOf[ConstantType]) {
+                assert(tree.symbol.accessed != NoSymbol)
                 assert(tree.symbol.accessed.getter(tree.symbol.owner) == tree.symbol ||
-                       tree.symbol.accessed.setter(tree.symbol.owner) == tree.symbol);
+                       tree.symbol.accessed.setter(tree.symbol.owner) == tree.symbol)
               }
             case ValDef(_, _, _, _) =>
               if (tree.symbol.hasGetter) {
@@ -84,23 +86,23 @@ abstract class TreeCheckers extends Analyzer {
             case Apply(_, args) =>
               assert(args forall (EmptyTree !=))
             case Select(_, _) =>
-              assert(tree.symbol != NoSymbol, tree);
-	    case This(_) =>
-	      if (!(tree.symbol.isStatic && (tree.symbol hasFlag MODULE))) {
-		var o = currentOwner;
-		while (o != tree.symbol) {
-		  o = o.owner;
-		  assert(o != NoSymbol, tree)
-		}
-	      }
+              assert(tree.symbol != NoSymbol, tree)
+            case This(_) =>
+              if (!(tree.symbol.isStatic && (tree.symbol hasFlag MODULE))) {
+                var o = currentOwner
+                while (o != tree.symbol) {
+                  o = o.owner
+                  assert(o != NoSymbol, tree)
+                }
+              }
             case _ =>
           }
-	  if (tree.pos == Position.NOPOS && tree != EmptyTree) {
-	    error(tree.pos, "tree without position: " + tree)
-	  } else if (tree.tpe == null && phase.id >= currentRun.typerPhase.id) {
-	    error(tree.pos, "tree without type: " + tree);
+          if (tree.pos == Position.NOPOS && tree != EmptyTree) {
+            error(tree.pos, "tree without position: " + tree)
+          } else if (tree.tpe == null && phase.id >= currentRun.typerPhase.id) {
+            error(tree.pos, "tree without type: " + tree)
           } else if (tree.isDef && tree.symbol.owner != currentOwner) {
-            var owner = currentOwner;
+            var owner = currentOwner
             while (owner.isTerm && !owner.isMethod && tree.symbol.owner != owner)
               owner = owner.owner;
             if (tree.symbol.owner != owner) {
@@ -113,26 +115,26 @@ abstract class TreeCheckers extends Analyzer {
           }
         } catch {
           case ex: Throwable =>
-	    if (settings.debug.value)
-	      System.out.println("exception when traversing " + tree);
-	    throw(ex)
+            if (settings.debug.value)
+              System.out.println("exception when traversing " + tree);
+            throw(ex)
         }
     }
 
     object postcheck extends Traverser {
       override def traverse(tree: Tree): unit = tree match {
-	case EmptyTree | TypeTree() =>
-	  ;
-	case _ =>
-	  tpeOfTree.get(tree) match {
-	    case Some(oldtpe) =>
-	      if (!(oldtpe =:= tree.tpe))
-		error(tree.pos, "types differ\n old: " + oldtpe + "\n new: " + tree.tpe +
-		      "\n tree: " + tree);
-	      tree.tpe = oldtpe;
-	      super.traverse(tree)
-	    case None =>
-	  }
+        case EmptyTree | TypeTree() =>
+          ;
+        case _ =>
+          tpeOfTree.get(tree) match {
+            case Some(oldtpe) =>
+              if (!(oldtpe =:= tree.tpe))
+                error(tree.pos, "types differ\n old: " + oldtpe +
+                      "\n new: " + tree.tpe + "\n tree: " + tree)
+              tree.tpe = oldtpe
+              super.traverse(tree)
+            case None =>
+          }
       }
     }
   }