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

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

7 files changed, 710 insertions, 641 deletions

diff --git a/src/compiler/scala/tools/nsc/FatalError.scala b/src/compiler/scala/tools/nsc/FatalError.scala
index 2abb503141..9026467b3c 100644
--- a/src/compiler/scala/tools/nsc/FatalError.scala
+++ b/src/compiler/scala/tools/nsc/FatalError.scala
@@ -1,8 +1,9 @@
-/* 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;
 
-case class FatalError(msg: String) extends Exception(msg);
+package scala.tools.nsc
+
+case class FatalError(msg: String) extends Exception(msg)
diff --git a/src/compiler/scala/tools/nsc/Phase.scala b/src/compiler/scala/tools/nsc/Phase.scala
index 4ca3aa2e9c..a27c71f961 100644
--- a/src/compiler/scala/tools/nsc/Phase.scala
+++ b/src/compiler/scala/tools/nsc/Phase.scala
@@ -1,35 +1,36 @@
-/* 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;
 
-import symtab.Flags;
+package scala.tools.nsc
+
+import symtab.Flags
 
 abstract class Phase(val prev: Phase) {
 
-  type Id = int;
+  type Id = int
 
-  val id: Id = if (prev == null) 0 else prev.id + 1;
+  val id: Id = if (prev == null) 0 else prev.id + 1
 
-  def newFlags: long = 0l;
+  def newFlags: long = 0l
   private var fmask: long =
-    if (prev == null) Flags.InitialFlags else prev.flagMask | newFlags;
-  def flagMask: long = fmask;
+    if (prev == null) Flags.InitialFlags else prev.flagMask | newFlags
+  def flagMask: long = fmask
 
-  private var nx: Phase = this;
-  if (prev != null) prev.nx = this;
+  private var nx: Phase = this
+  if (prev != null) prev.nx = this
 
-  def next: Phase = nx;
+  def next: Phase = nx
 
-  def name: String;
-  def description: String = name;
-  def erasedTypes: boolean = false;
-  def flatClasses: boolean = false;
-  def run: unit;
+  def name: String
+  def description: String = name
+  def erasedTypes: boolean = false
+  def flatClasses: boolean = false
+  def run: unit
 
-  override def toString() = name;
+  override def toString() = name
 }
 
 
diff --git a/src/compiler/scala/tools/nsc/models/Models.scala b/src/compiler/scala/tools/nsc/models/Models.scala
index b503c18586..8ab0cea160 100644
--- a/src/compiler/scala/tools/nsc/models/Models.scala
+++ b/src/compiler/scala/tools/nsc/models/Models.scala
@@ -1,107 +1,109 @@
-/* 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.models;
 
-import scala.tools.nsc.Global;
-import scala.tools.nsc.util.Position;
+package scala.tools.nsc.models
 
+import scala.tools.nsc.Global
+import scala.tools.nsc.util.Position
+
+/** This abstract class..
+ *
+ *  @author Sean McDirmid
+ *  #version 1.0
+ */
 abstract class Models {
-  val global : Global;
-  import global._;
+  val global : Global
+  import global._
 
-  def acceptPrivate = true;
+  def acceptPrivate = true
 
   abstract class Kind {}
-  object CONSTRUCTOR extends Kind;
-  object OBJECT  extends Kind;
-  object CLASS   extends Kind;
-  object TRAIT   extends Kind;
-  object   DEF   extends Kind;
-  object   VAL   extends Kind;
-  object   VAR   extends Kind;
-  object   ARG   extends Kind;
-  object  TPARAM extends Kind;
-
-  val KINDS = CONSTRUCTOR :: TPARAM :: CLASS :: TRAIT :: OBJECT :: VAL :: VAR :: DEF :: Nil;
-
-  def labelFor(kind : Kind) : String = kind match {
-  case OBJECT => "Object";
-  case CLASS  => "Class";
-  case TRAIT  => "Trait";
-  case DEF    => "Def";
-  case VAL    => "Val";
-  case VAR    => "Var";
-  case ARG    => "Arg";
-  case TPARAM => "Type";
-  case CONSTRUCTOR => "Constructor";
-  };
-  def stringsFor(mods : Modifiers) = {
-    var modString : List[String] = Nil;
-    if (mods . isPrivate  ) modString = "private"   :: modString;
-    if (mods . isProtected) modString = "protected" :: modString;
-    if (mods . isOverride ) modString = "override"  :: modString;
-    if (mods . isAbstract ) modString = "abstract"  :: modString;
-    if (mods . isCase     ) modString = "case"      :: modString;
-    if (mods . isSealed   ) modString = "sealed"    :: modString;
-    if (mods . isFinal    ) modString = "final"    :: modString;
-    if (mods . isTrait    ) modString = "mixin"    :: modString;
-    modString;
+  object CONSTRUCTOR extends Kind
+  object OBJECT extends Kind
+  object CLASS  extends Kind
+  object TRAIT  extends Kind
+  object DEF    extends Kind
+  object VAL    extends Kind
+  object VAR    extends Kind
+  object ARG    extends Kind
+  object TPARAM extends Kind
+
+  val KINDS = CONSTRUCTOR :: TPARAM :: CLASS :: TRAIT :: OBJECT :: VAL :: VAR :: DEF :: Nil
+
+  def labelFor(kind: Kind): String = kind match {
+    case OBJECT => "Object"
+    case CLASS  => "Class"
+    case TRAIT  => "Trait"
+    case DEF    => "Def"
+    case VAL    => "Val"
+    case VAR    => "Var"
+    case ARG    => "Arg"
+    case TPARAM => "Type"
+    case CONSTRUCTOR => "Constructor"
+  }
+  def stringsFor(mods: Modifiers) = {
+    var modString: List[String] = Nil
+    if (mods.isPrivate  ) modString = "private"   :: modString
+    if (mods.isProtected) modString = "protected" :: modString
+    if (mods.isOverride ) modString = "override"  :: modString
+    if (mods.isAbstract ) modString = "abstract"  :: modString
+    if (mods.isCase     ) modString = "case"      :: modString
+    if (mods.isSealed   ) modString = "sealed"    :: modString
+    if (mods.isFinal    ) modString = "final"     :: modString
+    if (mods.isTrait    ) modString = "mixin"     :: modString
+    modString
   }
 
+  def codeFor(kind: Kind) : String = kind match {
+    case CONSTRUCTOR => codeFor(DEF)
+    case _ => labelFor(kind).toLowerCase()
+  }
 
-  def codeFor(kind : Kind) : String = kind match {
-    case CONSTRUCTOR => codeFor(DEF);
-    case _ => labelFor(kind).toLowerCase();
+  def pluralFor(kind: Kind) : String = kind match {
+    case CLASS  => "Classes"
+    case _ => labelFor(kind) + "s"
   }
 
-  def pluralFor(kind : Kind) : String = kind match {
-  case CLASS  => "Classes";
-  case _ => labelFor(kind) + "s";
-  };
-
-  def kindOf(term0 : Symbol) = {
-         if (term0.isVariable)       VAR;
-    else if (term0.isValueParameter) ARG;
-    else if (term0.isMethod)         {
-      if (term0.nameString.equals("this")) CONSTRUCTOR;
-      else DEF;
+  def kindOf(term0: Symbol) = {
+    if (term0.isVariable) VAR
+    else if (term0.isValueParameter) ARG
+    else if (term0.isMethod) {
+      if (term0.nameString.equals("this")) CONSTRUCTOR
+      else DEF
     }
-    else if (term0.isClass)          CLASS;
-    else if (term0.isModule)         OBJECT;
-    else if (term0.isValue   )       VAL;
-    else if (term0.isTypeParameter)  TPARAM;
-    else if (term0.isType         )  TPARAM;
+    else if (term0.isClass) CLASS
+    else if (term0.isModule) OBJECT
+    else if (term0.isValue) VAL
+    else if (term0.isTypeParameter) TPARAM
+    else if (term0.isType) TPARAM
     else {
       // System.err.println("UNRECOGNIZED SYMBOL: " + term0 + " " + name);
-      null;
+      null
     }
-  };
+  }
 
   abstract class Listener {
-	    def    add(from : Composite, model : HasTree) : Unit;
-	    def remove(from : Composite, model : HasTree) : Unit;
-
+    def add(from: Composite, model: HasTree): Unit
+    def remove(from: Composite, model: HasTree): Unit
   }
-  abstract class Model extends Listener;
-
-  // def textFor(tp : AbsTypeDef) : String = tp.toString();
-
+  abstract class Model extends Listener
 
-  def textFor(tree : Tree) : String = {
-    var ret = "";
-    if (tree.symbol != NoSymbol) tree.symbol.name.toString();
-    if (ret.equals("<init>")) ret = "this";
+  // def textFor(tp : AbsTypeDef) : String = tp.toString()
+  def textFor(tree: Tree): String = {
+    var ret = ""
+    if (tree.symbol != NoSymbol) tree.symbol.name.toString()
+    if (ret.equals("<init>")) ret = "this"
     tree match {
-      case cdef : ClassDef =>
+      case cdef: ClassDef =>
         ret = ret + "[" +
           (for (val tparam <- cdef.tparams) yield textFor(tparam)) + "]";
-        cdef.mods;
-      case vdef : ValOrDefDef =>
+        cdef.mods
+      case vdef: ValOrDefDef =>
         vdef match {
-          case ddef : DefDef =>
+          case ddef: DefDef =>
           ret = ret + "[" +
             (for (val tparam <- ddef.tparams) yield textFor(tparam)) + "]";
           for (val vparams <- ddef.vparamss) {
@@ -110,268 +112,298 @@ abstract class Models {
           }
           case _ =>
         }
-        ret = ret + " : " + textFor(vdef.tpt);
-      case atd : AbsTypeDef =>
-      	ret = ret + ((if(atd.hi != null) " <: " + textFor(atd.hi) else "") +
-      	             (if(atd.lo != null) " >: " + textFor(atd.lo) else ""));
-      case _ => ret = ret + tree.toString();
+        ret = ret + " : " + textFor(vdef.tpt)
+      case atd: AbsTypeDef =>
+        ret = ret + ((if(atd.hi != null) " <: " + textFor(atd.hi) else "") +
+                     (if(atd.lo != null) " >: " + textFor(atd.lo) else ""));
+      case _ =>
+        ret = ret + tree.toString()
     }
-		ret;
+    ret
   }
 
   def mods1(tree: Tree) = tree match {
-    case mdef : MemberDef => mdef.mods
+    case mdef: MemberDef => mdef.mods
     case _ => NoMods
   }
 
-  abstract class HasTree(val parent : Composite) extends Model with Ordered[HasTree] {
-    var tree : Tree = _;
-    def update(tree0 : Tree): Boolean = {
-      tree = tree0;
-      false;
+  abstract class HasTree(val parent: Composite) extends Model with Ordered[HasTree] {
+    var tree : Tree = _
+    def update(tree0: Tree): Boolean = {
+      tree = tree0
+      false
     }
-    def replacedBy(tree0 : Tree) : Boolean = true;
-    def text : String = textFor(tree);
-    var mods0 = NoMods;
+    def replacedBy(tree0: Tree) : Boolean = true
+    def text: String = textFor(tree)
+    var mods0 = NoMods
 
-    def mods = if (mods0 != NoMods) mods0 else mods1(tree);
+    def mods = if (mods0 != NoMods) mods0 else mods1(tree)
 
-    override def toString() : String = tree.toString();
+    override def toString(): String = tree.toString()
 
     def compare (ht: HasTree): Int = {
-      val result = tree.symbol.nameString.compare(ht.tree.symbol.nameString);
-      if (result != 0) result;
+      val result = tree.symbol.nameString.compare(ht.tree.symbol.nameString)
+      if (result != 0) result
       else toString().compare(ht.toString())
     }
 
-    def kind = kindOf(tree.symbol);
+    def kind = kindOf(tree.symbol)
 
-    override def    add(from : Composite, model : HasTree) : Unit = { parent.add(from, model); }
-    override def remove(from : Composite, model : HasTree) : Unit = { parent.remove(from, model); }
+    override def    add(from: Composite, model: HasTree): Unit = { parent.add(from, model) }
+    override def remove(from: Composite, model: HasTree): Unit = { parent.remove(from, model) }
   }
-  class ImportMod(parent0 : Composite) extends HasTree(parent0) {
-    def treex = tree.asInstanceOf[Import];
 
-    override def replacedBy(tree0 : Tree) : Boolean = if (super.replacedBy(tree0) && tree0.isInstanceOf[Import]) {
-      val tree1 = tree0.asInstanceOf[Import];
-      tree1.tpe == treex.tpe;
-    } else false;
-  }
-  class PackageMod(parent0 : Composite) extends HasTree(parent0) {
-	    def treex = tree.asInstanceOf[PackageDef];
-	}
+  class ImportMod(parent0: Composite) extends HasTree(parent0) {
+    def treex = tree.asInstanceOf[Import]
 
-  trait Composite extends Model {
-    import scala.collection.mutable._;
+    override def replacedBy(tree0: Tree): Boolean =
+      if (super.replacedBy(tree0) && tree0.isInstanceOf[Import]) {
+        val tree1 = tree0.asInstanceOf[Import]
+        tree1.tpe == treex.tpe
+      } else
+        false
+  }
 
+  class PackageMod(parent0: Composite) extends HasTree(parent0) {
+    def treex = tree.asInstanceOf[PackageDef]
+  }
 
-    class Members extends HashSet[HasTree] with ObservableSet[HasTree, Members];
-	//    val members = new Members;
-    object members extends Members;
+  trait Composite extends Model {
+    import scala.collection.mutable._
 
+    class Members extends HashSet[HasTree] with ObservableSet[HasTree, Members]
+    // val members = new Members;
+    object members extends Members
 
     object subscriber extends Subscriber[Message[HasTree] with Undoable, Members] {
-    	def notify(pub: Members, event: Message[HasTree] with Undoable): Unit = event match {
-				//case Include(elem) =>    add(Composite.this, i.elem);
-				//case  Remove(elem) => remove(Composite.this, i.elem);
-				case i : Include[HasTree] with Undoable  =>    add(Composite.this, i.elem);
-				case r : Remove [HasTree] with Undoable  => remove(Composite.this, r.elem);
-			}
+      def notify(pub: Members, event: Message[HasTree] with Undoable): Unit = event match {
+        //case Include(elem) =>    add(Composite.this, i.elem)
+        //case  Remove(elem) => remove(Composite.this, i.elem)
+        case i: Include[HasTree] with Undoable  =>    add(Composite.this, i.elem)
+        case r: Remove [HasTree] with Undoable  => remove(Composite.this, r.elem)
+      }
     }
-    members.subscribe(subscriber);
+    members.subscribe(subscriber)
 
+    def isMember(tree: Tree): Boolean = tree.isInstanceOf[Import] // imports welcome anywhere.
 
-
-
-
-    def isMember(tree : Tree) : Boolean = tree.isInstanceOf[Import]; // imports welcome anywhere.
-
-    def member(tree: Tree, members : List[Tree]) : Tree = tree;
+    def member(tree: Tree, members: List[Tree]): Tree = tree
 
     def update0(members1 : List[Tree]) : Boolean = {
       // System.err.println("update0 " + this + " " + members1);
       if (members1.length == 1 && members1.head.isInstanceOf[PackageDef])
-    	  return update0(members1.head.asInstanceOf[PackageDef].stats);
+        return update0(members1.head.asInstanceOf[PackageDef].stats)
 
-      val marked = new HashSet[HasTree];
-      var updated = false;
+      val marked = new HashSet[HasTree]
+      var updated = false
       for (val mmbr1 <- members1) if (mmbr1.isInstanceOf[PackageDef]) {
-    	  System.err.println("PACKAGE: " + mmbr1.symbol + " " + members1.length);
-
+        System.err.println("PACKAGE: " + mmbr1.symbol + " " + members1.length)
       } else if (isMember(mmbr1)) {
-				val mmbr2 = member(mmbr1, members1);
-				if (mmbr2 != null) {
-				  var found = false;
-				  for (val mmbr <- members) if (!found && mmbr.replacedBy(mmbr2)) {
-            //System.err.println("REPLACE: " + mmbr + " with " + mmbr2);
-            mmbr.mods0 = mods1(mmbr1);
-				    found = true;
-				    updated = mmbr.update(mmbr2) || updated;
-				    marked += mmbr;
-				  }
-				  if (!found) {
-				    updated = true;
-				    val add = modelFor(mmbr2, this);
-				    add.update(mmbr2);
-            val sz = members.size;
-				    members += (add);
-            assert(members.size == sz + 1);
-				    marked += add;
-				  }
-				}
-				// System.err.println("update1 " + this + " " + members + " " + marked);
+        val mmbr2 = member(mmbr1, members1)
+        if (mmbr2 != null) {
+          var found = false
+          for (val mmbr <- members) if (!found && mmbr.replacedBy(mmbr2)) {
+            //System.err.println("REPLACE: " + mmbr + " with " + mmbr2)
+            mmbr.mods0 = mods1(mmbr1)
+            found = true
+            updated = mmbr.update(mmbr2) || updated
+            marked += mmbr
+          }
+          if (!found) {
+            updated = true
+            val add = modelFor(mmbr2, this)
+            add.update(mmbr2)
+            val sz = members.size
+            members += (add)
+            assert(members.size == sz + 1)
+            marked += add
+          }
+        }
+        // System.err.println("update1 " + this + " " + members + " " + marked)
       }
       val sz = members.size;
       members.intersect(marked);
       updated = updated || sz < members.size;
       // check if anything was removed!
-      updated;
+      updated
     }
   }
-  abstract class MemberMod(parent0 : Composite) extends HasTree(parent0) {
-    def treex = tree.asInstanceOf[MemberDef];
+  abstract class MemberMod(parent0: Composite) extends HasTree(parent0) {
+    def treex = tree.asInstanceOf[MemberDef]
 
-    def name : Name = { treex.name; }
+    def name: Name = { treex.name; }
 
-    override def replacedBy(tree0 : Tree) : Boolean = if (super.replacedBy(tree0) && tree0.isInstanceOf[MemberDef]) {
-      val tree1 = tree0.asInstanceOf[MemberDef];
-      treex.toString().equals(tree1.toString());
-    } else false;
+    override def replacedBy(tree0: Tree): Boolean =
+      if (super.replacedBy(tree0) && tree0.isInstanceOf[MemberDef]) {
+        val tree1 = tree0.asInstanceOf[MemberDef]
+        treex.toString().equals(tree1.toString())
+      } else false
 
-    override def update(tree0 : Tree): Boolean = {
-      val updated = tree == null || (treex.mods != tree0.asInstanceOf[MemberDef].mods);
+    override def update(tree0: Tree): Boolean = {
+      val updated = tree == null || (treex.mods != tree0.asInstanceOf[MemberDef].mods)
       super.update(tree0) || updated;
     }
   }
-  abstract class MemberComposite(parent0: Composite) extends MemberMod(parent0) with Composite;
+
+  abstract class MemberComposite(parent0: Composite) extends MemberMod(parent0) with Composite
 
   trait HasClassObjects extends Composite {
-    override def isMember(tree : Tree) : Boolean = (super.isMember(tree) ||
-      (tree.isInstanceOf[ImplDef]));
+    override def isMember(tree: Tree): Boolean =
+      super.isMember(tree) || tree.isInstanceOf[ImplDef]
   }
-  abstract class ValOrDefMod(parent0: Composite) extends MemberComposite(parent0) with HasClassObjects {
-    def treey = tree.asInstanceOf[ValOrDefDef];
-    override def replacedBy(tree0 : Tree) : Boolean = (super.replacedBy(tree0) && tree0.isInstanceOf[ValOrDefDef]);
 
-    override def update(tree0 : Tree): Boolean = {
-      val tree1 = tree0.asInstanceOf[ValOrDefDef];
-      val updated = tree == null || treex.tpe != tree1.tpe;
-      update0(flatten(tree1.rhs, (tree2 : Tree) => isMember(tree2)));
-      super.update(tree0) || updated;
+  abstract class ValOrDefMod(parent0: Composite) extends MemberComposite(parent0) with HasClassObjects {
+    def treey = tree.asInstanceOf[ValOrDefDef]
+    override def replacedBy(tree0: Tree): Boolean =
+      super.replacedBy(tree0) && tree0.isInstanceOf[ValOrDefDef]
+
+    override def update(tree0: Tree): Boolean = {
+      val tree1 = tree0.asInstanceOf[ValOrDefDef]
+      val updated = tree == null || treex.tpe != tree1.tpe
+      update0(flatten(tree1.rhs, (tree2 : Tree) => isMember(tree2)))
+      super.update(tree0) || updated
     }
   }
+
   class ValMod(parent0: Composite) extends ValOrDefMod(parent0) {
-    def treez = tree.asInstanceOf[ValDef];
-    override def replacedBy(tree0 : Tree) : Boolean = (super.replacedBy(tree0) && tree0.isInstanceOf[ValDef]);
+    def treez = tree.asInstanceOf[ValDef]
+    override def replacedBy(tree0: Tree): Boolean =
+      super.replacedBy(tree0) && tree0.isInstanceOf[ValDef]
   }
+
   class DefMod(parent0: Composite) extends ValOrDefMod(parent0) {
-    def treez = tree.asInstanceOf[DefDef];
-
-    override def replacedBy(tree0 : Tree) : Boolean = if (super.replacedBy(tree0) && tree0.isInstanceOf[DefDef]) {
-      val tree1 = tree0.asInstanceOf[DefDef];
-      if (tree1.vparamss.length == treez.vparamss.length) {
-				val tpz = for (val vd <- treez.vparamss) yield for (val xd <- vd) yield xd.tpe;
-				val tp1 = for (val vd <- tree1.vparamss) yield for (val xd <- vd) yield xd.tpe;
-				tpz == tp1;
-      } else false;
-    } else false;
+    def treez = tree.asInstanceOf[DefDef]
+
+    override def replacedBy(tree0: Tree) : Boolean =
+      if (super.replacedBy(tree0) && tree0.isInstanceOf[DefDef]) {
+        val tree1 = tree0.asInstanceOf[DefDef]
+        if (tree1.vparamss.length == treez.vparamss.length) {
+          val tpz = for (val vd <- treez.vparamss) yield for (val xd <- vd) yield xd.tpe;
+          val tp1 = for (val vd <- tree1.vparamss) yield for (val xd <- vd) yield xd.tpe;
+          tpz == tp1
+        } else false
+      } else false
   }
+
   abstract class ImplMod(parent0: Composite) extends MemberComposite(parent0) with HasClassObjects {
-    def treey = tree.asInstanceOf[ImplDef];
-    override def replacedBy(tree0 : Tree) : Boolean = (super.replacedBy(tree0) && tree0.isInstanceOf[ImplDef]);
-    override def isMember(tree : Tree) : Boolean = (super.isMember(tree) ||
+    def treey = tree.asInstanceOf[ImplDef]
+    override def replacedBy(tree0: Tree): Boolean =
+      super.replacedBy(tree0) && tree0.isInstanceOf[ImplDef]
+    override def isMember(tree: Tree): Boolean = (super.isMember(tree) ||
       (tree.isInstanceOf[ValOrDefDef] &&
         (acceptPrivate || !tree.asInstanceOf[ValOrDefDef].mods.isPrivate)
        /* && !tree.asInstanceOf[ValOrDefDef].mods.isPrivate */
        /* && !tree.asInstanceOf[ValOrDefDef].mods.isAccessor */) ||
       tree.isInstanceOf[AliasTypeDef]);
 
-
-    override def member(tree : Tree, members : List[Tree]) : Tree = {
+    override def member(tree: Tree, members: List[Tree]): Tree = {
       val tree0 = if (tree.isInstanceOf[DefDef]) {
-				val ddef = tree.asInstanceOf[DefDef];
-				if (ddef.mods.isAccessor && ddef.symbol != null) {
-				  val sym = ddef.symbol.accessed;
-				  val ret = for (val member <- members; member.symbol == sym) yield {
+        val ddef = tree.asInstanceOf[DefDef]
+        if (ddef.mods.isAccessor && ddef.symbol != null) {
+          val sym = ddef.symbol.accessed
+          val ret = for (val member <- members; member.symbol == sym) yield {
             member;
           }
-				  if (ret.isEmpty) null;
-				  else ret.head;
-				} else tree;
-      } else super.member(tree, members);
+          if (ret.isEmpty) null
+          else ret.head
+        } else tree
+      } else super.member(tree, members)
 
-      def sym = tree0.symbol;
-      if (tree0 == null || sym.pos == Position.NOPOS) null;
+      def sym = tree0.symbol
+      if (tree0 == null || sym.pos == Position.NOPOS) null
       else if (!acceptPrivate &&
         tree0.isInstanceOf[ValOrDefDef] && tree0.asInstanceOf[ValOrDefDef].mods.isPrivate) null;
       else tree0;
     }
 
+    def children(tree0: Tree): List[Tree] =
+      tree0.asInstanceOf[ImplDef].impl.body
 
-    def children(tree0 : Tree) : List[Tree] = tree0.asInstanceOf[ImplDef].impl.body;
-
-    override def update(tree0 : Tree): Boolean = {
-      var updated = update0(children(tree0));
-      (super.update(tree0) || updated);
+    override def update(tree0: Tree): Boolean = {
+      var updated = update0(children(tree0))
+      super.update(tree0) || updated
     }
   }
+
   class  ClassMod(parent0: Composite) extends ImplMod(parent0) {
-    def treez = tree.asInstanceOf[ClassDef];
-    override def replacedBy(tree0 : Tree) : Boolean = (super.replacedBy(tree0) && tree0.isInstanceOf[ClassDef]);
+    def treez = tree.asInstanceOf[ClassDef]
+    override def replacedBy(tree0: Tree): Boolean =
+      super.replacedBy(tree0) && tree0.isInstanceOf[ClassDef]
   }
+
   class ObjectMod(parent0: Composite) extends ImplMod(parent0) {
-    def treez = tree.asInstanceOf[ModuleDef];
-    override def replacedBy(tree0 : Tree) : Boolean = (super.replacedBy(tree0) && tree0.isInstanceOf[ModuleDef]);
+    def treez = tree.asInstanceOf[ModuleDef]
+    override def replacedBy(tree0: Tree): Boolean =
+      super.replacedBy(tree0) && tree0.isInstanceOf[ModuleDef]
   }
+
   class AliasTypeMod(parent0: Composite) extends MemberMod(parent0) {
-    def treey = tree.asInstanceOf[AliasTypeDef];
-    override def replacedBy(tree0 : Tree) : Boolean = (super.replacedBy(tree0) && tree0.isInstanceOf[AliasTypeDef]);
+    def treey = tree.asInstanceOf[AliasTypeDef]
+    override def replacedBy(tree0: Tree): Boolean =
+      super.replacedBy(tree0) && tree0.isInstanceOf[AliasTypeDef]
   }
+
   class AbsTypeMod(parent0: Composite) extends HasTree(parent0) {
-    def treey = tree.asInstanceOf[AbsTypeDef];
-    override def replacedBy(tree0 : Tree) : Boolean = (super.replacedBy(tree0) && tree0.isInstanceOf[AbsTypeDef]);
+    def treey = tree.asInstanceOf[AbsTypeDef]
+    override def replacedBy(tree0: Tree): Boolean =
+      super.replacedBy(tree0) && tree0.isInstanceOf[AbsTypeDef]
   }
-  class SourceMod(val original : CompilationUnit) extends Composite with HasClassObjects {
-    update(original);
-    var listener : Listener = null;
-    def update(unit : CompilationUnit) = unit.body match {
-      case pdef : PackageDef => update0(pdef.stats);
+
+  class SourceMod(val original: CompilationUnit) extends Composite with HasClassObjects {
+    update(original)
+    var listener: Listener = null
+    def update(unit: CompilationUnit) = unit.body match {
+      case pdef: PackageDef => update0(pdef.stats)
       case _ =>
     }
 
-    override def    add(from : Composite, model : HasTree) : Unit = if (listener != null) { listener.add(from, model); }
-    override def remove(from : Composite, model : HasTree) : Unit = if (listener != null) { listener.remove(from, model); }
+    override def add(from: Composite, model: HasTree): Unit =
+      if (listener != null) listener.add(from, model)
+
+    override def remove(from: Composite, model: HasTree): Unit =
+      if (listener != null) listener.remove(from, model)
 
-    override def isMember(tree : Tree) : Boolean = super.isMember(tree) || tree.isInstanceOf[Import];
+    override def isMember(tree: Tree): Boolean =
+      super.isMember(tree) || tree.isInstanceOf[Import]
   }
 
-  def flatten0(exprs : List[Tree], filter: (Tree) => Boolean) : List[Tree] =
-    for (val expr <- exprs; val t : Tree <- flatten(expr,filter)) yield t;
+  def flatten0(exprs: List[Tree], filter: (Tree) => Boolean): List[Tree] =
+    for (val expr <- exprs; val t: Tree <- flatten(expr,filter)) yield t;
 
   def flatten(expr : Tree, filter: (Tree) => Boolean) : List[Tree] =
     if (filter(expr)) expr :: Nil; else expr match {
-      case Block(stats,last) => flatten0(stats, filter) ::: flatten(last, filter);
-      case If(cond,thenp,elsep) => flatten(cond,filter) ::: flatten(thenp,filter) ::: flatten(elsep,filter);
-      case Assign(lhs,rhs) => flatten(rhs,filter);
-      case CaseDef(pat,guard,body) => flatten(body,filter);
-      case Return(expr0) => flatten(expr0,filter);
-      case  Throw(expr0) => flatten(expr0,filter);
-      case Try(block,catches,finalizer) => flatten(block,filter) ::: flatten(finalizer,filter) ::: flatten0(catches, filter);
-      case Match(selector,cases) => flatten(selector,filter) ::: flatten0(cases, filter);
-      case Apply(fun,args) => flatten(fun,filter) ::: flatten0(args,filter);
-      case TypeApply(fun,args) => flatten(fun,filter) ::: flatten0(args,filter);
-      case _ => Nil;
+      case Block(stats, last) =>
+        flatten0(stats, filter) ::: flatten(last, filter)
+      case If(cond, thenp, elsep) =>
+        flatten(cond,filter) ::: flatten(thenp,filter) ::: flatten(elsep,filter);
+      case Assign(lhs, rhs) =>
+        flatten(rhs, filter)
+      case CaseDef(pat, guard, body) =>
+        flatten(body, filter)
+      case Return(expr0) =>
+        flatten(expr0, filter)
+      case Throw(expr0) =>
+        flatten(expr0,filter)
+      case Try(block, catches, finalizer) =>
+        flatten(block, filter) ::: flatten(finalizer, filter) ::: flatten0(catches, filter)
+      case Match(selector, cases) =>
+        flatten(selector, filter) ::: flatten0(cases, filter)
+      case Apply(fun, args) =>
+        flatten(fun, filter) ::: flatten0(args, filter)
+      case TypeApply(fun, args) =>
+        flatten(fun, filter) ::: flatten0(args, filter)
+      case _ =>
+        Nil
     }
 
-
   def modelFor(tree: Tree, parent: Composite): HasTree = tree match {
-    case _:    ValDef => new    ValMod(parent);
-    case _:    DefDef => new    DefMod(parent);
-    case _:  ClassDef => new  ClassMod(parent);
-    case _: ModuleDef => new ObjectMod(parent);
-    case _: AliasTypeDef => new AliasTypeMod(parent);
-    case _: AbsTypeDef => new AbsTypeMod(parent);
-    case _: Import => new ImportMod(parent);
+    case _: ValDef       => new ValMod(parent)
+    case _: DefDef       => new DefMod(parent)
+    case _: ClassDef     => new ClassMod(parent)
+    case _: ModuleDef    => new ObjectMod(parent)
+    case _: AliasTypeDef => new AliasTypeMod(parent)
+    case _: AbsTypeDef   => new AbsTypeMod(parent)
+    case _: Import       => new ImportMod(parent)
   }
 
 }
diff --git a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
index fa35acc45d..5f6c3a6ceb 100644
--- a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
+++ b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
@@ -4,101 +4,104 @@
  */
 // $Id$
 
-package scala.tools.nsc.models;
-
-import scala.tools.nsc.Global;
-import scala.tools.nsc.symtab.{Flags,Names};
-import scala.tools.nsc.util.{NameTransformer,Position,SourceFile};
-import scala.collection.mutable.{HashMap,HashSet};
+package scala.tools.nsc.models
 
+import scala.collection.mutable.{HashMap,HashSet}
+import scala.tools.nsc.Global
+import scala.tools.nsc.symtab.{Flags,Names}
+import scala.tools.nsc.util.{NameTransformer,Position,SourceFile}
 
 class SemanticTokens(val compiler: Global) {
-  import compiler._;
+  import compiler._
 
   abstract class Kind {}
-  object OBJECT  extends Kind;
-  object CLASS   extends Kind;
-  object TRAIT   extends Kind;
-  object   DEF   extends Kind;
-  object   VAL   extends Kind;
-  object   VAR   extends Kind;
-  object   ARG   extends Kind;
-  object  TPARAM extends Kind;
+  object OBJECT extends Kind
+  object CLASS  extends Kind
+  object TRAIT  extends Kind
+  object DEF    extends Kind
+  object VAL    extends Kind
+  object VAR    extends Kind
+  object ARG    extends Kind
+  object TPARAM extends Kind
 
   // static constants here
 
   abstract class Token {
-    def length: Int;
-    def prev: HasNext;
-    def next: HasPrev;
+    def length: Int
+    def prev: HasNext
+    def next: HasPrev
   }
-  def eatKeyword(source : SourceFile, pos : Int, keywords : List[String]) : Int = {
-    if (keywords.isEmpty) pos;
-    else if (pos == source.content.length) Position.NOPOS;
+
+  def eatKeyword(source: SourceFile, pos: Int, keywords: List[String]) : Int = {
+    if (keywords.isEmpty)
+      pos
+    else if (pos == source.content.length)
+      Position.NOPOS
     else if (source.beginsWith(pos, " "))
-      eatKeywords(source, pos + 1);
+      eatKeywords(source, pos + 1)
     else if (source.beginsWith(pos, keywords.head + " "))
-      eatKeywords(source, pos + keywords.head.length() + 1);
-    else eatKeyword(source, pos, keywords.tail);
+      eatKeywords(source, pos + keywords.head.length() + 1)
+    else
+      eatKeyword(source, pos, keywords.tail)
   }
 
-  def eatKeywords(source : SourceFile, pos : Int) : Int = {
+  def eatKeywords(source: SourceFile, pos: Int): Int = {
     val keywords =
       "package" :: "val" :: "var" :: "def" :: "class" :: "trait" :: "override" :: "case" ::
-      "object" :: "sealed" :: "private" :: "protected" :: Nil;
-    if (pos != Position.NOPOS) eatKeyword(source, pos, keywords);
-    else pos;
+      "object" :: "sealed" :: "private" :: "protected" :: Nil
+    if (pos != Position.NOPOS) eatKeyword(source, pos, keywords)
+    else pos
   }
 
   trait HasNext extends Token {
-    var next0: HasPrev = _;
-    def next = next0;
+    var next0: HasPrev = _
+    def next = next0
   }
 
   trait HasPrev extends Token {
-    var prev0: HasNext = _;
-    def prev = prev0;
+    var prev0: HasNext = _
+    def prev = prev0
   }
 
   abstract class Actual extends HasNext with HasPrev {
     def convertToGap: Pair[Int, Actual]  = {
-      val nextGap = next.isInstanceOf[Gap];
-      val prevGap = prev.isInstanceOf[Gap];
+      val nextGap = next.isInstanceOf[Gap]
+      val prevGap = prev.isInstanceOf[Gap]
 
       if (prevGap) {
-        val ret = prev.length;
-        val gap = prev.asInstanceOf[Gap];
-        gap.setLength(gap.length + length);
+        val ret = prev.length
+        val gap = prev.asInstanceOf[Gap]
+        gap.setLength(gap.length + length)
         if (nextGap) {
-          gap.setLength(gap.length + next.length);
-          gap.next0 = next.next;
+          gap.setLength(gap.length + next.length)
+          gap.next0 = next.next
           next.next.prev0 = gap
         } else {
-          gap.next0 = next;
+          gap.next0 = next
           next.prev0 = gap
         }
-        new Pair(ret, gap);
+        new Pair(ret, gap)
       }
       else if (nextGap) {
-        val gap = next.asInstanceOf[Gap];
-        gap.setLength(gap.length + length);
-        gap.prev0 = prev;
-        prev.next0 = gap;
+        val gap = next.asInstanceOf[Gap]
+        gap.setLength(gap.length + length)
+        gap.prev0 = prev
+        prev.next0 = gap
         new Pair(0, gap)
       }
       else {
-        prev.next0 = next;
-        next.prev0 = prev;
-        val gap = new Gap(prev);
-        gap.setLength(length);
+        prev.next0 = next
+        next.prev0 = prev
+        val gap = new Gap(prev)
+        gap.setLength(length)
         new Pair(0, gap)
       }
 
     }
     def insert(prev1: HasNext) = {
-      next0 = prev1.next;
-      prev0 = prev1;
-      prev0.next0 = this;
+      next0 = prev1.next
+      prev0 = prev1
+      prev0.next0 = this
       next0.prev0 = this
     }
 
@@ -106,23 +109,23 @@ class SemanticTokens(val compiler: Global) {
 
   final class Gap extends Actual {
     def this(prev1: HasNext) = {
-      this();
-      insert(prev1);
+      this()
+      insert(prev1)
     }
     override def toString() = "gap-" + length;
 
-    var length0 : Int = -1;
-    def length  : Int = length0;
-    def setLength(length1: Int) = length0 = length1;
+    var length0: Int = -1
+    def length: Int = length0
+    def setLength(length1: Int) = length0 = length1
 
     // already gap
-    override def convertToGap: Pair[Int,Actual] = new Pair(0, this);
+    override def convertToGap: Pair[Int,Actual] = new Pair(0, this)
   }
 
-  def Process(unit : CompilationUnit) = new Process(unit);
-  class Process(val unit : CompilationUnit) {
-    private var doLog = true;
-    def source = unit.source;
+  def Process(unit: CompilationUnit) = new Process(unit)
+  class Process(val unit: CompilationUnit) {
+    private var doLog = true
+    def source = unit.source
 
     def dbg(tree : Tree) = {(
         "TREE=" + tree +
@@ -136,13 +139,14 @@ class SemanticTokens(val compiler: Global) {
 
 
     class Info(val symbol: Symbol) {
-      var defined : Def = _;
-      val uses = new HashSet[Use];
-      symbols.update(symbol, this);
+      var defined : Def = _
+      val uses = new HashSet[Use]
+      symbols.update(symbol, this)
     }
+
     def info(symbol: Symbol): Info =
       if (symbols.contains(symbol)) symbols(symbol)
-      else new Info(symbol);
+      else new Info(symbol)
 
     abstract class Semantic(val symbol: Symbol) extends Actual {
       val name = NameTransformer.decode(symbol.name.toString()).toString().trim();
@@ -172,136 +176,135 @@ class SemanticTokens(val compiler: Global) {
     }
 
     class Def(symbol0: Symbol) extends Semantic(symbol0) {
-      info.defined = this;
-      override def toString() = "def-" + name + "-" + symbol.getClass();
+      info.defined = this
+      override def toString() = "def-" + name + "-" + symbol.getClass()
     }
     class Use(symbol0: Symbol, tpe0: Type) extends Semantic(symbol0) {
-      info.uses += this;
+      info.uses += this
 
       override def tpe : Type = if (tpe0 != null) tpe0 else super.tpe;
       override def toString() = "use-" + name + "-" + symbol.getClass();
     }
-    val list = new TokenList;
+    val list = new TokenList
 
-    build(unit.body);
+    build(unit.body)
 
     // ok start building....
     def build[T <: Tree](trees : List[T]) : Unit =
-      for (val tree : T <- trees) build(tree);
+      for (val tree : T <- trees) build(tree)
 
     def build(tree0: Tree) : Unit = try {
       /* if (tree0.pos != Position.NOPOS) */ tree0 match {
-      case tree : ImplDef =>
-        val pos = eatKeywords(unit.source, tree.pos);
+      case tree: ImplDef =>
+        val pos = eatKeywords(unit.source, tree.pos)
         if (pos == Position.NOPOS) {
           // inner types.
             // System.err.println("NOPOS: " + tree.getClass() + " " + (new Position(unit.source, tree.pos)).dbgString);
           //Thread.dumpStack();
         } else buildDef(tree.symbol, eatKeywords(unit.source, tree.pos));
         tree match {
-        case cdef : ClassDef => build(cdef.tparams);
-        case   _  => ;
+          case cdef: ClassDef => build(cdef.tparams)
+          case _ => ;
         }
-        build(tree.impl.parents);
-        build(tree.impl.body);
-      case tree : ValOrDefDef =>
+        build(tree.impl.parents)
+        build(tree.impl.body)
+      case tree: ValOrDefDef =>
         if (!tree.symbol.hasFlag(Flags.ACCESSOR)) {
-			  {
-			    val pos = if (tree.name.toString().equals("<init>")) Position.NOPOS else
+              {
+                val pos = if (tree.name.toString().equals("<init>")) Position.NOPOS else
             eatKeywords(unit.source, tree.pos);
           if (false) System.err.println("VALDEF: tree=" + tree + " sym=" + tree.symbol + " pos0=" +
             tree.symbol.pos + " alias=" + tree.symbol.alias + " pos1=" +
             pos + " pos2=" + tree.pos + " " + unit.source.dbg(tree.pos) + " " + tree.symbol.hasFlag(Flags.SYNTHETIC));
 
-			    if (pos != Position.NOPOS && !tree.hasFlag(Flags.SYNTHETIC))
-			        buildDef(tree.symbol, pos);
-			  }
-
-			  if (tree.isInstanceOf[DefDef]) {
-			    val ddef = tree.asInstanceOf[DefDef];
-			    build(ddef.tparams);
-
-			    for (val l0 <- ddef.vparamss; val arg <- l0) {
-			      val pos0 = if (!unit.source.beginsWith(arg.pos, "val ")) arg.pos;
-											 else unit.source.skipWhitespace(arg.pos + ("val ").length());
-			      buildDef(arg.symbol, pos0);
-			      build(arg.tpt);
-			    }
-			  }
-			  try {
+                if (pos != Position.NOPOS && !tree.hasFlag(Flags.SYNTHETIC))
+                    buildDef(tree.symbol, pos);
+              }
+
+              if (tree.isInstanceOf[DefDef]) {
+                val ddef = tree.asInstanceOf[DefDef];
+                build(ddef.tparams);
+
+                for (val l0 <- ddef.vparamss; val arg <- l0) {
+                  val pos0 = if (!unit.source.beginsWith(arg.pos, "val ")) arg.pos;
+                                             else unit.source.skipWhitespace(arg.pos + ("val ").length());
+                  buildDef(arg.symbol, pos0);
+                  build(arg.tpt);
+                }
+              }
+              try {
           //TPT=scala.Iterator[DocGenerator.this.compiler0.CompilationUnit] 260 class scala.tools.nsc.ast.Trees$TypeTree scala.Iterator[DocGenerator.this.compiler0.CompilationUnit] class scala.tools.nsc.symtab.Types$$anon$5
           if (tree.tpt == null || tree.tpt.tpe == null) {
             //System.err.println("BAD: " + tree.tpt + " in " + tree);
           } else {
             //System.err.println("TPT=" + tree.tpt + " " + tree.tpt.pos + " " + tree.tpt.getClass() + " " + tree.tpt.tpe + " " + tree.tpt.tpe.getClass() + " " + tree.tpt.tpe.getClass().getSuperclass());
-  			    build(tree.tpt);
+                  build(tree.tpt);
           }
-			  } catch {
-			    case e: Error =>
-			      System.err.println("VALDEF: " + tree + " " + tree.tpt + " " + tree.pos + " " + tree.tpt.pos);
-			      throw e;
-			  }
+              } catch {
+                case e: Error =>
+                  System.err.println("VALDEF: " + tree + " " + tree.tpt + " " + tree.pos + " " + tree.tpt.pos);
+                  throw e;
+              }
         //System.err.println("RHS: " + tree.rhs + " " + tree.rhs.getClass() + " " + tree.rhs.getClass().getSuperclass());
-			  build(tree.rhs);
-			}
-	  case tree : PackageDef =>
-			//System.err.println("PACKAGE: " + tree.name);
-			if (false) {
-			  val pos = eatKeywords(unit.source, tree.pos);
-		    if (pos != Position.NOPOS)
-			    buildDef(tree.symbol, pos);
-			}
-			build(tree.stats);
-	  case tree : Function   =>
-	    for (val arg <- tree.vparams) if (arg.pos != Position.NOPOS) {
-				  val name = arg.name.toString().trim();
-				  val pos : Int =
-			    if (unit.source.beginsWith(arg.pos, "val ")) unit.source.skipWhitespace(arg.pos + ("val ").length());
-			    else if (unit.source.content(arg.pos) == ':') {
-			      var posx = arg.pos;
-			      while (Character.isWhitespace(unit.source.content(posx - 1))) posx = posx - 1;
-			      posx - name.length();
-			    } else arg.pos;
-				  buildDef(arg.symbol, pos);
-				  build(arg.tpt);
-				}
-	    build(tree.body);
-	  case tree : TypeTree =>
-      val treex = tree;
-	    val tree1 = if (tree.original != null) tree.original; else tree;
-      def classes(clazz : java.lang.Class) : List[java.lang.Class] =
-        if (clazz == null) Nil;
-        else clazz :: classes(clazz.getSuperclass());
-      if (tree.original == null) {
-        if (false) System.err.println("NO_ORIGINAL: " + tree + " " + tree.tpe + " " + classes(tree.tpe.getClass()));
-
-      }
-
-	    if (tree.tpe != null) buildT(tree1, tree.tpe);
-	    def buildT( tree : Tree, tpe : Type) : Unit = if (tree.pos != Position.NOPOS) tpe match {
-		  case tpe0 : TypeRef => tree match {
-		    case apt : AppliedTypeTree =>
-		      buildUse(tpe.symbol, apt.tpt.pos, tpe0);
+              build(tree.rhs);
+            }
+      case tree: PackageDef =>
+        //System.err.println("PACKAGE: " + tree.name);
+        if (false) {
+          val pos = eatKeywords(unit.source, tree.pos)
+          if (pos != Position.NOPOS)
+            buildDef(tree.symbol, pos)
+        }
+        build(tree.stats)
+      case tree: Function =>
+        for (val arg <- tree.vparams) if (arg.pos != Position.NOPOS) {
+          val name = arg.name.toString().trim()
+          val pos: Int =
+            if (unit.source.beginsWith(arg.pos, "val "))
+              unit.source.skipWhitespace(arg.pos + ("val ").length())
+            else if (unit.source.content(arg.pos) == ':') {
+              var posx = arg.pos
+              while (Character.isWhitespace(unit.source.content(posx - 1))) posx = posx - 1
+              posx - name.length()
+            } else arg.pos
+          buildDef(arg.symbol, pos)
+          build(arg.tpt)
+        }
+        build(tree.body)
+      case tree : TypeTree =>
+        val treex = tree
+        val tree1 = if (tree.original != null) tree.original else tree
+        def classes(clazz: java.lang.Class): List[java.lang.Class] =
+          if (clazz == null) Nil
+          else clazz :: classes(clazz.getSuperclass())
+        if (tree.original == null) {
+          if (false) System.err.println("NO_ORIGINAL: " + tree + " " + tree.tpe + " " + classes(tree.tpe.getClass()));
+        }
+        if (tree.tpe != null) buildT(tree1, tree.tpe);
+        def buildT( tree : Tree, tpe : Type) : Unit = if (tree.pos != Position.NOPOS) tpe match {
+          case tpe0 : TypeRef => tree match {
+            case apt : AppliedTypeTree =>
+              buildUse(tpe.symbol, apt.tpt.pos, tpe0);
           //System.err.println("APT: " + treex + " vs. " + treex.original);
           //System.err.println("APT: " + treex.pos + " vs. " + treex.original.pos + " " + unit.source.dbg(treex.original.pos));
-		      //System.err.println("APT: " + apt.tpt + " sym0=" + apt.tpt.symbol + " sym1=" + tpe0.sym + " apt.args=" + apt.args + " tpe0.args=" + tpe0.args);
+              //System.err.println("APT: " + apt.tpt + " sym0=" + apt.tpt.symbol + " sym1=" + tpe0.sym + " apt.args=" + apt.args + " tpe0.args=" + tpe0.args);
 
-		      buildTs (apt.args, tpe0.args);
-		    case ident : Ident => buildUse(tpe0.sym, ident.pos, tpe0);
-		    case select : Select =>
+              buildTs (apt.args, tpe0.args);
+            case ident : Ident => buildUse(tpe0.sym, ident.pos, tpe0);
+            case select : Select =>
           if (select.symbol == NoSymbol)
             if (false) System.err.println("BUILD_SELECT: " + select + " @ " + tpe0 + " SYM=" + select.symbol + " " + unit.source.dbg(select.pos));
-		      try {
-		        // build(select);
+              try {
+                // build(select);
             buildUse(tpe0.symbol, selectPos(select), tpe0);
             //System.err.println("QUALIFIER: " + select.qualifier + " " + unit.source.dbg(select.qualifier.pos) + " " + tpe0.prefix + " " + tpe0.prefix.getClass() + " " + tpe0.prefix.getClass().getSuperclass() +" " + tpe0.prefix.widen + " " + tpe0.prefix.toLongString);
-						buildT(select.qualifier, tpe0.prefix);
+                        buildT(select.qualifier, tpe0.prefix);
           } catch {
-						case e : Error =>
-						  System.err.println("BUILD_SELECT: " + select + " @ " + tpe0 + " " + unit.source.dbg(select.pos));
-						  throw e;
-		      }
-		    case tpt : TypeTree =>
+                        case e : Error =>
+                          System.err.println("BUILD_SELECT: " + select + " @ " + tpe0 + " " + unit.source.dbg(select.pos));
+                          throw e;
+              }
+            case tpt : TypeTree =>
           if (tpt.symbol != null) {
             System.err.println("SYM0 " + tpt.symbol + " " + unit.source.dbg(tpt.pos));
             buildUse(tpt.symbol, tpt.pos, tpe0);
@@ -311,36 +314,36 @@ class SemanticTokens(val compiler: Global) {
           } else {
             System.err.println("UNKNOWN TPT0: " + unit.source.dbg(tpt.pos) + " tpt=" + tpt + " " + tpt.symbol + " tpe0="+ tpe0 + " " + tpe0.symbol + " tpe0.args=" + tpe0.args);
           }
-		    case sft : SelectFromTypeTree =>
-		      build(sft.qualifier); // XXX: broken
-			    if (false) System.err.println("SFTT: " + sft + " sym=" + sft.symbol + " selector=" + sft.selector + " qual=" + sft.qualifier + " qual.sym=" +
-						  sft.qualifier.symbol +
-						  " qual.pos=" + unit.source.dbg(sft.qualifier.pos) + " symbol=" + sft.symbol + " type=" + tpe0 +
-						  " type.sym=" + tpe0.symbol);
-		    case _ => System.err.println("UNKNOWN TPT2: " + tree + " vs. " + tpe0 + " " + tree.getClass() + " " + unit.source.content(tree.pos));
-		  }
-		  case tpe0 : MethodType => tree match {
-		    case tpt: TypeTree =>
-		      if (tpt.original != null) buildT(tpt.original, tpe);
-		      else {
-						System.err.println("UNKNOWN TPT3: " + tree + " vs. " + tpe0 + " " + unit.source.content(tree.pos));
-		      }
-		    case ident  : Ident  => buildT(ident,  tpe0.resultType);
-		    case select : Select => buildT(select, tpe0.resultType);
-		    case _ => System.err.println("UNKNOWN TPE: " + tree + " vs. " + tpe0 + " " + tree.getClass());
-		  }
-		  case tpe0 : RefinedType => tree match {
-			  case cpt : CompoundTypeTree =>
-			  	buildTs(cpt.templ.parents, tpe0.parents);
-
-			  case _ : TypeTree =>
-			    // System.err.println("UNKNOWN TPE13: " + dbg(tree) + " tpe0=" + tpe0 + " " + tpe0.parents);
-			  case _ =>
-				  if (false) System.err.println("UNKNOWN TPE5: " + dbg(tree) + " tpe0=" + tpe0 + " " + tpe0.parents);
-		  }
-		  case tpe0 : ThisType => tree match {
-  		  case stt : SingletonTypeTree => stt.ref match {
-  			  case ths : This => build(ths);
+            case sft : SelectFromTypeTree =>
+              build(sft.qualifier); // XXX: broken
+                if (false) System.err.println("SFTT: " + sft + " sym=" + sft.symbol + " selector=" + sft.selector + " qual=" + sft.qualifier + " qual.sym=" +
+                          sft.qualifier.symbol +
+                          " qual.pos=" + unit.source.dbg(sft.qualifier.pos) + " symbol=" + sft.symbol + " type=" + tpe0 +
+                          " type.sym=" + tpe0.symbol);
+            case _ => System.err.println("UNKNOWN TPT2: " + tree + " vs. " + tpe0 + " " + tree.getClass() + " " + unit.source.content(tree.pos));
+          }
+          case tpe0 : MethodType => tree match {
+            case tpt: TypeTree =>
+              if (tpt.original != null) buildT(tpt.original, tpe);
+              else {
+                        System.err.println("UNKNOWN TPT3: " + tree + " vs. " + tpe0 + " " + unit.source.content(tree.pos));
+              }
+            case ident  : Ident  => buildT(ident,  tpe0.resultType);
+            case select : Select => buildT(select, tpe0.resultType);
+            case _ => System.err.println("UNKNOWN TPE: " + tree + " vs. " + tpe0 + " " + tree.getClass());
+          }
+          case tpe0 : RefinedType => tree match {
+              case cpt : CompoundTypeTree =>
+                  buildTs(cpt.templ.parents, tpe0.parents);
+
+              case _ : TypeTree =>
+                // System.err.println("UNKNOWN TPE13: " + dbg(tree) + " tpe0=" + tpe0 + " " + tpe0.parents);
+              case _ =>
+                  if (false) System.err.println("UNKNOWN TPE5: " + dbg(tree) + " tpe0=" + tpe0 + " " + tpe0.parents);
+          }
+          case tpe0 : ThisType => tree match {
+            case stt : SingletonTypeTree => stt.ref match {
+                case ths : This => build(ths);
           case _ => System.err.println("UNKNOWN TPE11: " + tpe0 + " " + stt + " " + stt.ref + " " + stt.ref.getClass() + " " + unit.source.dbg(tree.pos));
         }
         case tt : This =>
@@ -350,8 +353,8 @@ class SemanticTokens(val compiler: Global) {
           if (false) System.err.println("UNKNOWN TPE12: " + tpe0 + " " + tree + " " + tree.getClass() + " " + unit.source.dbg(tree.pos));
         case _ =>
           if (false) System.err.println("UNKNOWN TPE10: " + tpe0 + " " + tree + " " + tree.getClass() + " " + unit.source.dbg(tree.pos));
-		  }
-		  case tpe0 : SingleType => tree match {
+          }
+          case tpe0 : SingleType => tree match {
         case ident  : Ident  => buildUse(tpe0.sym, ident.pos, tpe0);
         case select : Select =>
         buildUse(tpe0.symbol, selectPos(select), tpe0);
@@ -361,129 +364,136 @@ class SemanticTokens(val compiler: Global) {
         case _ =>
           if (false) System.err.println("UNKNOWN TPE8: " + tree + " " + unit.source.dbg(tree.pos) + " TPE=" + tpe0 + " PRE=" + tpe0.pre + " SYM=" + tpe0.sym);
 
-		  }
+          }
       case ctype : ConstantType =>
         if (false) System.err.println("UNKNOWN CONSTANT_TYPE: " + tree + " " + ctype + " " + unit.source.dbg(tree.pos));
 
-		  case ErrorType =>
-		  case _ => {
+          case ErrorType =>
+          case _ => {
         if (false) System.err.println("UNKNOWN TPE4: " + tree + " " + tpe + " " + tpe.getClass() + " " + unit.source.dbg(tree.pos));
-		  }
-		};
+          }
+        };
     def buildTs(trees : List[Tree], types : List[Type]): Unit = if (!trees.isEmpty && !types.isEmpty) {
-			  buildT (trees.head, types.head);
-			  buildTs(trees.tail, types.tail);
-		} else if (trees.isEmpty != types.isEmpty) {
- 			if (false && doLog) {
+              buildT (trees.head, types.head);
+              buildTs(trees.tail, types.tail);
+        } else if (trees.isEmpty != types.isEmpty) {
+             if (false && doLog) {
         Console.println("" + treex + " vs. " + treex.original);
         if (treex.original != null)
           Console.println("" + treex.tpe + " vs. " + treex.original.tpe);
- 			  logError("Tree vs. Type mismatch: " + trees + " " + types + " " + unit.source.dbg(tree.pos), null);
+               logError("Tree vs. Type mismatch: " + trees + " " + types + " " + unit.source.dbg(tree.pos), null);
         doLog = false;
       }
     };
 
-	  case tree : AbsTypeDef =>
-    	//System.err.println("ABS: " + tree.symbol + " " + unit.source.dbg(tree.namePos) + " " + unit.source.dbg(tree.pos));
-	    buildDef(tree.symbol, tree.namePos);
-	    buildDef(tree.symbol, tree.pos);
-	    build(tree.lo);
-      build(tree.hi);
-	  case tree : Bind =>       buildDef(tree.symbol, tree.pos);
-	                            build(tree.body);
-	  case tree : Ident      => buildUse(tree.symbol, tree.pos, tree.tpe);
-	  case tree : Select     =>
-			try {
-      	build(tree.qualifier);
-			} catch {
-			  case e : Error => System.err.println("SELECTQ: " + tree + " " + tree.qualifier + " " + unit.source.dbg(tree.qualifier.pos)); throw e;
-			}
-			try {
-			  if (tree.pos >= unit.source.content.length) {
-			    if (false) System.err.println("BAD_SELECT_QUALIFIER " + tree + " @ " + unit.source.dbg(tree.pos));
+      case tree: AbsTypeDef =>
+        //System.err.println("ABS: " + tree.symbol + " " + unit.source.dbg(tree.namePos) + " " + unit.source.dbg(tree.pos));
+        buildDef(tree.symbol, tree.namePos)
+        buildDef(tree.symbol, tree.pos)
+        build(tree.lo)
+        build(tree.hi)
+      case tree: Bind =>
+        buildDef(tree.symbol, tree.pos)
+        build(tree.body)
+      case tree: Ident =>
+        buildUse(tree.symbol, tree.pos, tree.tpe)
+      case tree: Select =>
+        try {
+          build(tree.qualifier)
+            } catch {
+              case e : Error => System.err.println("SELECTQ: " + tree + " " + tree.qualifier + " " + unit.source.dbg(tree.qualifier.pos)); throw e;
+            }
+            try {
+              if (tree.pos >= unit.source.content.length) {
+                if (false) System.err.println("BAD_SELECT_QUALIFIER " + tree + " @ " + unit.source.dbg(tree.pos));
 
         } else {
           //System.err.println("SELECT-0: " + tree.symbol + " " + unit.source.dbg(tree.pos) + " " + (tree.pos - selectPos(tree)));
-					buildUse(tree.symbol, selectPos(tree), tree.tpe);
-			  }
-			} catch {
-			  case e : Error => System.err.println("SELECTU: " + tree + " " + tree.symbol + " " + unit.source.dbg(tree.pos)); throw e;
-			}
-    case tree : TypeApply =>
-		  //System.err.println("TYPE_APPLY: " + tree + " " + unit.source.dbg(tree.pos));
+                    buildUse(tree.symbol, selectPos(tree), tree.tpe);
+              }
+            } catch {
+              case e : Error => System.err.println("SELECTU: " + tree + " " + tree.symbol + " " + unit.source.dbg(tree.pos)); throw e;
+            }
+    case tree: TypeApply =>
+      //System.err.println("TYPE_APPLY: " + tree + " " + unit.source.dbg(tree.pos));
       if (!tree.args.isEmpty) {
         //System.err.println("ARGS: " + unit.source.dbg(tree.args0.head.pos));
       }
-      build(tree.fun);
-      build(tree.args);
-    case tree : Apply =>
+      build(tree.fun)
+      build(tree.args)
+    case tree: Apply =>
       //System.err.println("NORM_APPLY: " + tree + " " + unit.source.dbg(tree.pos));
-      build(tree.fun);
-      build(tree.args);
-	  case tree : GenericApply =>
-	    //System.err.println("GEN_APPLY: " + tree + " " + unit.source.dbg(tree.pos));
-  	    build(tree.fun);
-	    build(tree.args);
-	  case tree : Typed =>
-            build(tree.expr);
-            build(tree.tpt);
-	  case tree : Block =>
-    	    if (false) {
-	      if (!tree.stats.isEmpty)
-                System.err.println("BLOCKS: " + tree.stats.head + " " + tree.stats.head.getClass());
-              System.err.println("BLOCKE: " + tree.expr + " " + tree.expr.getClass());
-            }
-	    build(tree.stats); build(tree.expr);
-	  case tree : CaseDef    =>
-	    build(tree.pat); build(tree.guard); build(tree.body);
-	  case tree : Sequence   => build(tree.trees);
-	  case tree : Assign     => build(tree.lhs); build(tree.rhs);
-	  case tree : If         => build(tree.cond); build(tree.thenp); build(tree.elsep);
-	  case tree : New        =>
-    	//System.err.println("NEW: " + tree.tpt + " " + tree.tpt.getClass());
+      build(tree.fun)
+      build(tree.args)
+      case tree: GenericApply =>
+        //System.err.println("GEN_APPLY: " + tree + " " + unit.source.dbg(tree.pos));
+        build(tree.fun)
+        build(tree.args)
+      case tree: Typed =>
+        build(tree.expr)
+        build(tree.tpt)
+      case tree: Block =>
+        if (false) {
+          if (!tree.stats.isEmpty)
+            System.err.println("BLOCKS: " + tree.stats.head + " " + tree.stats.head.getClass());
+          System.err.println("BLOCKE: " + tree.expr + " " + tree.expr.getClass())
+        }
+        build(tree.stats)
+        build(tree.expr)
+      case tree: CaseDef =>
+        build(tree.pat)
+        build(tree.guard)
+        build(tree.body)
+      case tree : Sequence   => build(tree.trees);
+      case tree : Assign     => build(tree.lhs); build(tree.rhs);
+      case tree : If         => build(tree.cond); build(tree.thenp); build(tree.elsep);
+      case tree : New        =>
+        //System.err.println("NEW: " + tree.tpt + " " + tree.tpt.getClass());
       build(tree.tpt);
-	  case tree : Match      => build(tree.selector); build(tree.cases);
-	  case tree : Return     => build(tree.expr);
-	  case tree : LabelDef   => build(tree.rhs);
-	  case tree : Throw      => build(tree.expr);
-	  case tree : Try        => build(tree.block); build(tree.catches); build(tree.finalizer);
-	  case tree : Alternative => build(tree.trees);
-	  case tree : This    =>
-    	//System.err.println("THIS: " + tree.symbol + " " + tree.qual + " " + unit.source.dbg(tree.pos) + " " + tree.tpe);
-	    if (tree.symbol != null) buildUse(tree.symbol, tree.pos, tree.tpe);
-	    //Thread.dumpStack();
-	  case tree : AliasTypeDef =>
-	    System.err.println("ALIAS: " + tree);
-	    build(tree.rhs); build(tree.tparams); buildDef(tree.symbol, tree.pos);
+      case tree : Match      => build(tree.selector); build(tree.cases);
+      case tree : Return     => build(tree.expr);
+      case tree : LabelDef   => build(tree.rhs);
+      case tree : Throw      => build(tree.expr);
+      case tree : Try        => build(tree.block); build(tree.catches); build(tree.finalizer);
+      case tree : Alternative => build(tree.trees);
+      case tree : This    =>
+        //System.err.println("THIS: " + tree.symbol + " " + tree.qual + " " + unit.source.dbg(tree.pos) + " " + tree.tpe);
+        if (tree.symbol != null) buildUse(tree.symbol, tree.pos, tree.tpe);
+        //Thread.dumpStack();
+      case tree : AliasTypeDef =>
+        System.err.println("ALIAS: " + tree);
+        build(tree.rhs); build(tree.tparams); buildDef(tree.symbol, tree.pos);
           case tree : DocDef     => build(tree.definition);
-	  case tree : Import     => build(tree.expr);
-    case tree : AppliedTypeTree => ;
-    case tree : SingletonTypeTree => ;
-    case tree : Super   => ;
-    case tree : Literal => ;
-	  case EmptyTree => ;
-	  case _ => ;
-	    System.err.println("BAIL: " + unit.source.dbg(tree0.pos) + " " + tree0 + " " + tree0.getClass());
+      case tree: Import => build(tree.expr)
+      case tree: AppliedTypeTree => ;
+      case tree: SingletonTypeTree => ;
+      case tree: Super   => ;
+      case tree: Literal => ;
+      case EmptyTree => ;
+      case _ => ;
+        System.err.println("BAIL: " + unit.source.dbg(tree0.pos) + " " + tree0 + " " + tree0.getClass());
     }
   } catch {
-    case t : Throwable => logError("Error occured at " + unit.source.dbg(tree0.pos), t);
+    case t: Throwable =>
+      logError("Error occured at " + unit.source.dbg(tree0.pos), t)
   }
 
-  def buildUse(term: Symbol, pos: Int, tpe: Type) = buildSym(term, pos, false, tpe);
-  def buildDef(term: Symbol, pos: Int) = buildSym(term, pos, true, null);
+  def buildUse(term: Symbol, pos: Int, tpe: Type) = buildSym(term, pos, false, tpe)
+  def buildDef(term: Symbol, pos: Int) = buildSym(term, pos, true, null)
 
-  def buildSym(term: Symbol, pos: Int, isDef: Boolean, tpe: Type) : Unit =
-    if (term.hasFlag(Flags.ACCESSOR)) buildSym(term.accessed, pos, isDef, tpe);
+  def buildSym(term: Symbol, pos: Int, isDef: Boolean, tpe: Type): Unit =
+    if (term.hasFlag(Flags.ACCESSOR))
+      buildSym(term.accessed, pos, isDef, tpe)
     else if (pos == Position.NOPOS) {
-      System.err.println("NOPOS: " + term);
-      Thread.dumpStack();
+      System.err.println("NOPOS: " + term)
+      Thread.dumpStack()
     }
     else if (term != NoSymbol) {
-      val name = NameTransformer.decode(term.name.toString()).toString().trim();
-      val buf = unit.source.content;
-      val cs = name.toChars;
-      var idx = 0;
-      if (cs.length + pos > buf.length) return;
+      val name = NameTransformer.decode(term.name.toString()).toString().trim()
+      val buf = unit.source.content
+      val cs = name.toChars
+      var idx = 0
+      if (cs.length + pos > buf.length) return
       else while (idx < cs.length) {
         if (buf(pos + idx) != cs(idx)) {
           //System.err.println("MISMATCH: " + name + "[" + idx + "] " + unit.source.dbg(pos));
@@ -506,51 +516,51 @@ class SemanticTokens(val compiler: Global) {
     }
 
   def selectPos(tree : Select): Int = if (tree.pos == Position.NOPOS) Position.NOPOS else {
-    val buf = unit.source.content;
+    val buf = unit.source.content
     if (tree.pos >= buf.length) {
       if (false) {
         System.err.println("" + tree + "@" + tree.pos + " not in " +
                            unit.source.file.name + "[" + buf.length + "]");
-        Thread.dumpStack();
-        throw new Error();
+        Thread.dumpStack()
+        throw new Error()
       }
-      return 0;
+      return 0
     }
 
     val pos =
-      if (buf(tree.pos) != '.') tree.pos;
+      if (buf(tree.pos) != '.') tree.pos
       else {
         def f(x : Int) : Int = {
-          if (Character.isWhitespace(buf(x))) f(x + 1);
-          else x;
+          if (Character.isWhitespace(buf(x))) f(x + 1)
+          else x
         }
-        f(tree.pos + 1);
+        f(tree.pos + 1)
       }
-    pos;
+    pos
   };
 
   class TokenList {
     object begin extends HasNext {
-        def prev = this;
-        def length = 0;
+      def prev = this
+      def length = 0
     }
     object end extends HasPrev {
-        def next = this;
-        def length = 0;
+      def next = this
+      def length = 0
     }
     // initialize
-    begin.next0 = end;
-    end.prev0 = begin;
+    begin.next0 = end
+    end.prev0 = begin
 
     def tokenAt(offset: Int) = {
-      cursor.seek(offset);
-      if (cursor.token.isInstanceOf[Semantic]) cursor.token.asInstanceOf[Semantic];
-      else null;
+      cursor.seek(offset)
+      if (cursor.token.isInstanceOf[Semantic]) cursor.token.asInstanceOf[Semantic]
+      else null
     }
 
     def put(offset: Int, tok: Actual): Unit = tok match {
-      case tok0 : Semantic => put(offset, tok0)
-      case gap  : Gap      =>
+      case tok0: Semantic => put(offset, tok0)
+      case gap: Gap      =>
     }
 
     def put(offset: Int, tok: Semantic): Unit = {
@@ -620,32 +630,32 @@ class SemanticTokens(val compiler: Global) {
     }
 
     override def toString() = {
-      var node = begin.next;
-      var str = "";
+      var node = begin.next
+      var str = ""
       while (node != end) {
-        str = str + " " + node;
-        node = node.next;
+        str = str + " " + node
+        node = node.next
       }
       str
     }
 
     object cursor {
-      var token  : Token = end;
-      var offset : Int   = 0;
+      var token: Token = end
+      var offset: Int = 0
 
-      def next : Unit = if (token == end) end else {
-        offset = offset + token.length;
-        token  = token.next;
+      def next: Unit = if (token == end) end else {
+        offset = offset + token.length
+        token  = token.next
       }
-      def prev : Unit = if (token.prev == begin) token else {
-        offset = offset - token.prev.length;
-        token = token.prev;
+      def prev: Unit = if (token.prev == begin) token else {
+        offset = offset - token.prev.length
+        token = token.prev
       }
       def seek(soffset : Int) : Unit = if (soffset == 0) {
-        token = begin.next;
-        offset = 0;
+        token = begin.next
+        offset = 0
       } else {
-        assert(soffset > 0);
+        assert(soffset > 0)
         while (offset                >  soffset) prev;
         while (offset + token.length <= soffset && token != end) {
           val len0 = offset;
diff --git a/src/compiler/scala/tools/nsc/models/Signatures.scala b/src/compiler/scala/tools/nsc/models/Signatures.scala
index 3a779a7021..6499352a7b 100644
--- a/src/compiler/scala/tools/nsc/models/Signatures.scala
+++ b/src/compiler/scala/tools/nsc/models/Signatures.scala
@@ -1,65 +1,74 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2006 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+// $Id$
 
-package scala.tools.nsc.models;
+package scala.tools.nsc.models
 
-import scala.tools.nsc.{Global => Compiler};
-import scala.tools.nsc.symtab.{Flags,Names};
-import scala.tools.nsc.util.{NameTransformer,Position,SourceFile};
-import scala.collection.mutable.{HashMap,HashSet};
+import scala.collection.mutable.{HashMap,HashSet}
+import scala.tools.nsc.{Global => Compiler}
+import scala.tools.nsc.symtab.{Flags,Names}
+import scala.tools.nsc.util.{NameTransformer,Position,SourceFile}
 
 class Signatures(val compiler: Compiler) {
-  import compiler._;
+  import compiler._
 
-  class Signature(val name : String, val children : List[Signature]) {
-	  def asString : String = name + "[" + asString0(children) + "]";
+  class Signature(val name: String, val children: List[Signature]) {
+    def asString : String = name + "[" + asString0(children) + "]"
   }
+
   def sort(sigs : List[Signature]) =
-	  sigs.sort((l0,l1) => l0.name.compareTo(l1.name) > 0);
+    sigs.sort((l0,l1) => l0.name.compareTo(l1.name) > 0);
 
   def asString0(sigs : List[Signature]) : String = {
-		var ret = "";
-		for (val sig <- sort(sigs))
-			ret = ret + sig.asString;
-		ret;
+    var ret = ""
+    for (val sig <- sort(sigs)) ret = ret + sig.asString
+    ret
   }
 
-  def signature(unit : CompilationUnit): String = asString0(signature(unit.body, Nil));
+  def signature(unit: CompilationUnit): String =
+    asString0(signature(unit.body, Nil))
 
-  def signature(trees : List[Tree]) : List[Signature] = {
-		var ret : List[Signature] = Nil;
-	  for (val tree <- trees) ret = signature(tree, ret);
-	  ret;
+  def signature(trees: List[Tree]): List[Signature] = {
+    var ret: List[Signature] = Nil
+    for (val tree <- trees) ret = signature(tree, ret)
+    ret
   }
-  def signature(tree0 : Tree, rest : List[Signature]) : List[Signature] = tree0 match {
-	case tree : MemberDef => if (!tree.mods.isPrivate) {
-			val name = "" + tree.name + "::" + tree.mods;
-			val children : List[Signature] = (tree match {
-				case impl : ImplDef =>
-					val supers = new Signature("$$supers", signature(impl.impl.parents));
-					val body   = new Signature("$$body",   signature(impl.impl.body));
-					val ret = supers :: body :: Nil;
-					(impl match {
-						case cdef : ClassDef =>  new Signature("$$tparams", signature(cdef.tparams)) :: ret;
-						case   _ => ret;
-					});
-				case vdef : ValOrDefDef =>
-					val ret = signature(vdef.tpt, Nil);
-					(vdef match {
-					case ddef : DefDef =>
-						val tparams = new Signature("$$tparams", signature(ddef.tparams));
-						var vparamss : List[Signature] = Nil;
-						for (val list <- ddef.vparamss) vparamss = signature(list) ::: vparamss;
-						tparams :: vparamss;
-					case _ => ret;
-				});
-				case pdef : PackageDef => signature(pdef.stats);
-				case _ => Nil;
-			});
-		  new Signature(name, children) :: rest;
 
-		} else rest;
-	case tree : TypeTree => new Signature("" + tree.tpe, Nil) :: rest;
-	case _ => rest;
-  }
+  def signature(tree0: Tree, rest: List[Signature]): List[Signature] = tree0 match {
+    case tree: MemberDef => if (!tree.mods.isPrivate) {
+      val name = "" + tree.name + "::" + tree.mods
+      val children : List[Signature] = (tree match {
+        case impl : ImplDef =>
+          val supers = new Signature("$$supers", signature(impl.impl.parents))
+          val body   = new Signature("$$body",   signature(impl.impl.body))
+          val ret = supers :: body :: Nil
+          (impl match {
+            case cdef: ClassDef => new Signature("$$tparams", signature(cdef.tparams)) :: ret;
+            case   _ => ret
+          });
+        case vdef: ValOrDefDef =>
+          val ret = signature(vdef.tpt, Nil)
+          (vdef match {
+          case ddef : DefDef =>
+            val tparams = new Signature("$$tparams", signature(ddef.tparams));
+            var vparamss : List[Signature] = Nil;
+            for (val list <- ddef.vparamss) vparamss = signature(list) ::: vparamss;
+            tparams :: vparamss;
+          case _ => ret;
+        });
+        case pdef : PackageDef => signature(pdef.stats);
+        case _ => Nil;
+      });
+      new Signature(name, children) :: rest;
 
+    } else
+      rest
+    case tree: TypeTree =>
+      new Signature("" + tree.tpe, Nil) :: rest
+    case _ =>
+      rest
+  }
 
 }
diff --git a/src/compiler/scala/tools/nsc/util/TreeSet.scala b/src/compiler/scala/tools/nsc/util/TreeSet.scala
index 507d6ff751..5939d914c1 100644
--- a/src/compiler/scala/tools/nsc/util/TreeSet.scala
+++ b/src/compiler/scala/tools/nsc/util/TreeSet.scala
@@ -1,20 +1,24 @@
-/* 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.util;
+
+package scala.tools.nsc.util
 
 /** Sets implemented as binary trees.
+ *
+ *  @author Martin Odersky
+ *  @version 1.0
  */
 class TreeSet[T >: Null <: AnyRef](less: (T, T) => boolean) extends Set[T] {
 
   private class Tree(val elem: T) {
-    var l: Tree = null;
-    var r: Tree = null;
+    var l: Tree = null
+    var r: Tree = null
   }
 
-  private var tree: Tree = null;
+  private var tree: Tree = null
 
   def findEntry(x: T): T = {
     def find(t: Tree): T = {
@@ -38,15 +42,15 @@ class TreeSet[T >: Null <: AnyRef](less: (T, T) => boolean) extends Set[T] {
 
   def elements = {
     def elems(t: Tree): Iterator[T] = {
-      var it = Iterator.single(t.elem);
-      if (t.l != null) it = elems(t.l) append it;
-      if (t.r != null) it = it append elems(t.r);
+      var it = Iterator.single(t.elem)
+      if (t.l != null) it = elems(t.l) append it
+      if (t.r != null) it = it append elems(t.r)
       it
     }
     if (tree == null) Iterator.empty else elems(tree)
   }
 
   override def toString(): String = {
-    if (tree == null) "<empty>" else "(..." + tree.elem + "...)";
+    if (tree == null) "<empty>" else "(..." + tree.elem + "...)"
   }
 }
diff --git a/test/scalatest b/test/scalatest
index 74f934a920..ffbeb482b9 100755
--- a/test/scalatest
+++ b/test/scalatest
@@ -144,6 +144,7 @@ test_print_help() {
     test_print_usage;
     echo "";
     echo "--auto          use filenames to select the test to run";
+    echo "--dis           next files test the class file disassembler";
     echo "--run           next files test the interpreter and all backends";
     echo "--jvm           next files test the JVM backend";
     echo "--pos           next files test a compilation success";
@@ -382,6 +383,8 @@ test_check_kind() {
 # Checks everything.
 test_check_all() {
     [ $# = 0 ] || abort "internal error";
+    test_check_kind "Testing disassembler" \
+        "dis" $FILES_DIS;
     test_check_kind "Testing JVM backend" \
         "jvm" $FILES_RUN $FILES_JVM;
     test_check_kind "Testing compiler (on files whose compilation should succeed)" \
@@ -411,6 +414,7 @@ test_add_file() {
     TEST_ALL="false";
     case "$TEST_TYPE" in
         auto   ) ;;
+        dis    ) FILES_DIS="$FILES_DIS $1"; return;;
         run    ) FILES_RUN="$FILES_RUN $1"; return;;
         jvm    ) FILES_JVM="$FILES_JVM $1"; return;;
         pos    ) FILES_POS="$FILES_POS $1"; return;;
@@ -420,6 +424,7 @@ test_add_file() {
         *      ) abort "unknown test type \`$TEST_TYPE'";;
     esac;
     case "$1" in
+        dis  | */dis  | */dis/*  | dis/*  ) FILES_DIS="$FILES_DIS $1";;
         run  | */run  | */run/*  | run/*  ) FILES_RUN="$FILES_RUN $1";;
         jvm5 | */jvm5 | */jvm5*  | jvm5/* )
             if [ "$JAVA5" = "true" ]; then
@@ -501,6 +506,7 @@ FILES_POS="";
 FILES_NEG="";
 FILES_MSIL="";
 FILES_SCRIPT="";
+FILES_DIS="";
 
 QUICK="$PREFIX/build/quick/bin"
 if [ -d "$PREFIX/dists" ]; then
@@ -531,6 +537,7 @@ esac;
 while [ $# -gt 0 ]; do
     case "$1" in
         --auto       ) TEST_TYPE="auto"; shift 1;;
+        --dis        ) TEST_TYPE="dis"; shift 1;;
         --run        ) TEST_TYPE="run"; shift 1;;
         --jvm        ) TEST_TYPE="jvm"; shift 1;;
         --pos        ) TEST_TYPE="pos"; shift 1;;
@@ -573,6 +580,9 @@ printf_initialization "${COLOR:-many}";
 
 if [ "$TEST_ALL" = "true" ]; then
     case "$TEST_TYPE" in
+        dis ) FILES_DIS="$FILES_DIS $SRCDIR/dis";;
+    esac;
+    case "$TEST_TYPE" in
         run ) FILES_RUN="$FILES_RUN $SRCDIR/run";;
     esac;
     case "$TEST_TYPE" in
@@ -598,7 +608,7 @@ fi;
 
 SCALA="${BIN_DIR}scala";
 SCALAC="${BIN_DIR}scalac -encoding iso-8859-1";
-SCALAP="${BIN_DIR}scalap";
+SCALAP="scalap";
 
 if [ -n "$OBJDIR" ]; then
     if [ -d "$OBJDIR" ] || mkdir -p "$OBJDIR"; then
@@ -615,6 +625,8 @@ if [ -z "$bin_dir" ]; then
     bin_dir=`test_get_location $scalac`;
 fi;
 printf_outline "Scala binaries in   : $bin_dir\\n";
+scala_version=`${BIN_DIR}scalac -version 2>&1`
+printf_outline "Scala version is    : $scala_version\\n";
 jvm_version=`${JAVACMD:=java} -version 2>&1 | head -3 | tail -1`
 printf_outline "Java runtime is     : $jvm_version\\n\\n";