Fixing bugs in new and old plugin.

9 files changed, 120 insertions, 45 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala
index 0ad3a5bc8a..d9f6220433 100644
--- a/src/compiler/scala/tools/nsc/ast/Trees.scala
+++ b/src/compiler/scala/tools/nsc/ast/Trees.scala
@@ -207,7 +207,11 @@ trait Trees {
       val results = for (i <- 0.until(this0.productArity).toList) yield
         equals0(this0.productElement(i), that0.productElement(i))
       val b = results.foldLeft(true)((x,y) => x && y)
-      b // ignore type!
+      if (b) (this,that) match {
+      case (this0 : TypeTree,that0 : TypeTree) if this0.original != null && that0.original != null =>
+        this0.original.equalsStructure0(that0.original)(f)
+      case _ => true
+      } else false
     }
 
     def duplicate: this.type =
diff --git a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
index 5ebe6510ad..1f246078f4 100644
--- a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
+++ b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
@@ -618,7 +618,8 @@ class SemanticTokens(val compiler: Global) {
           Console.err.println("LIST  =" + this);
           Console.err.println("OFFSET=" + offset + " " + tok + " " + tok.length);
           Console.err.println("       " + cursor.offset + " " + gap.length);
-          throw new Error();
+          gap.length0 = offset - cursor.offset + tok.length
+          //throw new Error();
         }
         if (offset == cursor.offset) {
           // replace or prepend
diff --git a/src/compiler/scala/tools/nsc/symtab/IdeSupport.scala b/src/compiler/scala/tools/nsc/symtab/IdeSupport.scala
index b240fd424c..dd9c529531 100644
--- a/src/compiler/scala/tools/nsc/symtab/IdeSupport.scala
+++ b/src/compiler/scala/tools/nsc/symtab/IdeSupport.scala
@@ -389,8 +389,8 @@ trait IdeSupport extends SymbolTable { // added to global, not analyzers.
     }
     // because module var shares space with monomorphic.
     if (existing.isModuleVar != symbol.isModuleVar) return NotCompatible
-    if ((existing.flags|MONOMORPHIC|DEFERRED|ABSTRACT|PRIVATE|PROTECTED|FINAL|SEALED|CASE) !=
-        (symbol.  flags|MONOMORPHIC|DEFERRED|ABSTRACT|PRIVATE|PROTECTED|FINAL|SEALED|CASE)) {
+    if ((existing.flags|LOCKED|INTERFACE|MONOMORPHIC|DEFERRED|ABSTRACT|PRIVATE|PROTECTED|FINAL|SEALED|CASE) !=
+        (symbol.  flags|LOCKED|INTERFACE|MONOMORPHIC|DEFERRED|ABSTRACT|PRIVATE|PROTECTED|FINAL|SEALED|CASE)) {
       return NotCompatible
     }
     if (((existing.flags&(MONOMORPHIC|INTERFACE)) != 0) ||
@@ -406,10 +406,10 @@ trait IdeSupport extends SymbolTable { // added to global, not analyzers.
     if (!ret) return NotCompatible
     existing.setPos(symbol.pos) // not significant for updating purposes.
     if ((existing.privateWithin != symbol.privateWithin ||
-        existing.name != symbol.name || ((existing.flags|MONOMORPHIC) != (symbol.flags|MONOMORPHIC)))) {
+        existing.name != symbol.name || ((existing.flags|LOCKED|MONOMORPHIC|INTERFACE) != (symbol.flags|LOCKED|MONOMORPHIC|INTERFACE)))) {
       existing.name = (symbol.name)
       // don't reset the monomorphic bit until we reset the type.
-      existing.flags = symbol.flags | (existing.flags&MONOMORPHIC)
+      existing.flags = symbol.flags
       existing.privateWithin = symbol.privateWithin
       return new Updated(existing)
     }
diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolWalker.scala b/src/compiler/scala/tools/nsc/symtab/SymbolWalker.scala
index e7cf3a20bd..78fd571379 100644
--- a/src/compiler/scala/tools/nsc/symtab/SymbolWalker.scala
+++ b/src/compiler/scala/tools/nsc/symtab/SymbolWalker.scala
@@ -192,9 +192,11 @@ trait SymbolWalker {
         f(tree.qualifier)
       }
       case tree : Literal =>
+      /*
         if (tree.tpe != null && tree.tpe.typeSymbol == definitions.ClassClass) {
           // nothing we can do without original tree.
         }
+      */
 
       case tree : Typed => f(tree.expr); f(tree.tpt)
       case tree : Block => fs(tree.stats); f(tree.expr)
diff --git a/src/compiler/scala/tools/nsc/typechecker/IdeSupport.scala b/src/compiler/scala/tools/nsc/typechecker/IdeSupport.scala
index 7b42a4c7c1..97484fbce4 100644
--- a/src/compiler/scala/tools/nsc/typechecker/IdeSupport.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/IdeSupport.scala
@@ -226,7 +226,10 @@ trait IdeSupport extends Analyzer {
       else if (namerTxt != NoContext && shouldBeTyped) {} else return fakeUpdate(lastTyped)
       val use = useTrees
       if (makeNoChanges) {}
-      else if (use.isEmpty || use.last.symbol != NoSymbol) return fakeUpdate(use) // already named
+      else if (use.isEmpty || use.last.symbol != NoSymbol) {
+        assert(true)
+        return fakeUpdate(use) // already named
+      }
 
       if (kind.isTop) namer.context.unit.source.file match {
       case file : io.PlainFile => reloadSource(file)
@@ -305,16 +308,16 @@ trait IdeSupport extends Analyzer {
         // the type changed in a good way.
         typeChanged
       }
-      if (!makeNoChanges && use.length != lastTyped.length || !use.zip(lastTyped).forall{
+      assert(true)
+      if (!makeNoChanges && (use.length != lastTyped.length || !use.zip(lastTyped).forall{
         case (t0,t1) => t0.equalsStructure0(t1){
         case (t0:StubTree,t1:StubTree) if t0.underlying == t0.underlying || true => true
         case _ => false
         }
-      }) {
+      })) {
         assert(true)
         highlightChanged
       }
-
       if (use.last.tpe == null) ErrorType else use.last.tpe
     }
   }
diff --git a/src/library/scala/collection/mutable/FlatHashTable.scala b/src/library/scala/collection/mutable/FlatHashTable.scala
index 05d08b3eb2..fb2499ae94 100644
--- a/src/library/scala/collection/mutable/FlatHashTable.scala
+++ b/src/library/scala/collection/mutable/FlatHashTable.scala
@@ -62,20 +62,21 @@ trait FlatHashTable[A] {
     null != entry
   }
 
-  def addEntry(elem: A) {
+  def addEntry(elem: A) : Boolean = {
     var h = index(elemHashCode(elem))
     var entry = table(h)
     while (null != entry) {
-      if (entry == elem) return
+      if (entry == elem) return false
       h = (h + 1) % table.length
       entry = table(h)
     }
     table(h) = elem.asInstanceOf[AnyRef]
     tableSize = tableSize + 1
     if (tableSize >= threshold) growTable()
+    true
   }
 
-  def removeEntry(elem: A) {
+  def removeEntry(elem: A) : Option[A] = {
     if (tableDebug) checkConsistent()
     def precedes(i: Int, j: Int) = {
       val d = table.length >> 1
@@ -101,11 +102,12 @@ trait FlatHashTable[A] {
         table(h0) = null
         tableSize -= 1
         if (tableDebug) checkConsistent()
-        return
+        return Some(entry.asInstanceOf[A])
       }
       h = (h + 1) % table.length
       entry = table(h)
     }
+    None
   }
 
   def elements = new Iterator[A] {
diff --git a/src/library/scala/collection/mutable/HashTable.scala b/src/library/scala/collection/mutable/HashTable.scala
index dbdb232a57..83187c15f8 100644
--- a/src/library/scala/collection/mutable/HashTable.scala
+++ b/src/library/scala/collection/mutable/HashTable.scala
@@ -78,13 +78,14 @@ trait HashTable[A] extends AnyRef {
       resize(2 * table.length)
   }
 
-  protected def removeEntry(key: A) {
+  protected def removeEntry(key: A) : Option[Entry] = {
     val h = index(elemHashCode(key))
     var e = table(h)
     if (e != null) {
       if (elemEquals(e.key, key)) {
         table(h) = e.next
         tableSize = tableSize - 1
+        return Some(e)
       } else {
         var e1 = e.next
         while (e1 != null && !elemEquals(e1.key, key)) {
@@ -94,9 +95,11 @@ trait HashTable[A] extends AnyRef {
         if (e1 != null) {
           e.next = e1.next
           tableSize = tableSize - 1
+          return Some(e1)
         }
       }
     }
+    None
   }
 
   protected def entries: Iterator[Entry] = new Iterator[Entry] {
diff --git a/src/library/scala/collection/mutable/LinkedHashMap.scala b/src/library/scala/collection/mutable/LinkedHashMap.scala
new file mode 100644
index 0000000000..b51cdb08ab
--- /dev/null
+++ b/src/library/scala/collection/mutable/LinkedHashMap.scala
@@ -0,0 +1,63 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+// $Id: HashMap.scala 10086 2007-02-21 19:10:41Z odersky $
+
+
+package scala.collection.mutable
+
+import Predef._
+
+/** This class implements mutable maps using a hashtable.
+ *
+ *  @author  Matthias Zenger
+ *  @author  Martin Odersky
+ *  @version 2.0, 31/12/2006
+ */
+object LinkedHashMap {
+
+  /** The empty map of this type */
+  def empty[A, B] = new LinkedHashMap[A, B]
+
+  /** The canonical factory for this type
+   */
+  def apply[A, B](elems: (A, B)*) = empty[A, B] ++ elems
+}
+
+@serializable
+class LinkedHashMap[A, B] extends Map[A,B] with HashTable[A] with DefaultMapModel[A,B] {
+  private var ordered = List[Entry]()
+
+  def remove(key : A) : Option[B] = removeEntry(key) match {
+  case None => None
+  case Some(e) =>
+    ordered = ordered.filter(_ ne e)
+    Some(e.value)
+  }
+  def -= (key: A) { remove(key) }
+  override def put(key : A, value : B) : Option[B] = {
+    val e = findEntry(key)
+    if (e == null) {
+      val e = new Entry(key, value)
+      ordered = e :: ordered
+      addEntry(e)
+      None
+    } else {
+      val ret = Some(e.value)
+      e.value = value
+      ret
+    }
+  }
+  override def update(key: A, value: B) { put(key, value) }
+  override def clear() = {
+    ordered = Nil
+    super.clear()
+  }
+  override def clone(): Map[A, B] = new LinkedHashMap[A, B] ++ this
+  override def elements = ordered.reverse.elements map {e => (e.key, e.value)}
+}
diff --git a/src/library/scala/collection/mutable/LinkedHashSet.scala b/src/library/scala/collection/mutable/LinkedHashSet.scala
index 21fd4845fb..b86bccd173 100644
--- a/src/library/scala/collection/mutable/LinkedHashSet.scala
+++ b/src/library/scala/collection/mutable/LinkedHashSet.scala
@@ -10,43 +10,40 @@
 
 package scala.collection.mutable
 
-/** This class...
- *
- *  @author Sean McDirmid
- *  @version 1.0
- */
-@deprecated class LinkedHashSet[A](private val set0 : java.util.LinkedHashSet[A]) extends Set[A] {
 
-  def this() = this(new java.util.LinkedHashSet[A])
+object LinkedHashSet {
+  /** The empty map of this type */
+  def empty[A] = new LinkedHashSet[A]
 
-  private def this(set1 : java.util.Set[A], b : Boolean) =
-    this(new java.util.LinkedHashSet[A](set1))
-
-  def contains(elem: A): Boolean = set0.contains(elem)
+  /** The canonical factory for this type
+   */
+  def apply[A](elems: A*) = empty[A] ++ elems
+}
 
-  def +=(elem: A): Unit = set0.add(elem)
+@serializable
+class LinkedHashSet[A] extends Set[A] with FlatHashTable[A] {
+  private var ordered = List[A]()
 
-  def ++=(set: LinkedHashSet[A]) = set0.addAll(set.set0)
-  def --=(set: LinkedHashSet[A]) = set0.removeAll(set.set0)
+  def contains(elem: A): Boolean = containsEntry(elem)
 
-  def -=(elem: A): Unit = set0.remove(elem)
+  def +=(elem: A) { add(elem) }
 
-  def elements = new Iterator[A] {
-    val i = set0.iterator
-    def hasNext = i.hasNext()
-    def next = i.next().asInstanceOf[A]
+  def add(elem : A) : Boolean = {
+    if (addEntry(elem)) {
+      ordered = elem :: ordered
+      true
+    } else false
   }
-
-  override def clear() = set0.clear()
-
-  def size = set0.size()
-
-  override def toString() = set0.toString()
-
-  override def clone(): Set[A] = {
-    val res = new LinkedHashSet[A](set0, true)
-    res ++= this
-    res
+  def -=(elem: A) { remove(elem) }
+  def remove(elem : A) : Boolean = removeEntry(elem) match {
+  case None => false
+  case Some(elem) => ordered = ordered.filter(e => e != elem); true
   }
 
+  override def clear() = {
+    ordered = Nil
+    super.clear()
+  }
+  override def clone(): Set[A] = new LinkedHashSet[A] ++ this
+  override def elements = ordered.reverse.elements
 }