Make remove operation of mutable.Set return a Boolean

Fix scala/collection-strawman#551

Author: julienrf

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -2502,7 +2502,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 
         // Remove ValDef for right-associative by-value operator desugaring which has been inlined into expr1
         val statsTyped2 = statsTyped match {
-          case (vd: ValDef) :: Nil if inlinedRightAssocValDefs.remove(vd.symbol).isDefined => Nil
+          case (vd: ValDef) :: Nil if inlinedRightAssocValDefs.remove(vd.symbol) => Nil
           case _ => statsTyped
         }
 

src/library/scala/collection/convert/Wrappers.scala

@@ -178,7 +178,7 @@ private[collection] trait Wrappers {
       sz < underlying.size
     }
     override def remove(elem: AnyRef) =
-      try underlying.remove(elem.asInstanceOf[A]).isDefined
+      try underlying.remove(elem.asInstanceOf[A])
       catch { case ex: ClassCastException => false }
     override def clear() = underlying.clear()
   }
@@ -195,8 +195,7 @@ private[collection] trait Wrappers {
     def addOne(elem: A): this.type = { underlying add elem; this }
     def subtractOne(elem: A): this.type = { underlying remove elem; this }
 
-    //TODO Should Set.remove return the canonical element? There is no efficient way to support this for wrapped Java Sets
-    override def remove(elem: A): Option[A] = if(underlying remove elem) Some(elem) else None
+    override def remove(elem: A): Boolean = underlying remove elem
     override def clear() = underlying.clear()
 
     //TODO Should Set.get be supported? There is no efficient way to return the canonical element from a Java Set

src/library/scala/collection/immutable/List.scala

@@ -7,9 +7,6 @@ import java.io.{ObjectInputStream, ObjectOutputStream}
 import scala.annotation.unchecked.uncheckedVariance
 import scala.annotation.tailrec
 import mutable.{Builder, ListBuffer, ReusableBuilder}
-import scala.collection.{LinearSeq, Seq}
-
-
 
 /** A class for immutable linked lists representing ordered collections
   *  of elements of type `A`.

src/library/scala/collection/mutable/LinkedHashSet.scala

@@ -72,17 +72,17 @@ class LinkedHashSet[A]
     this
   }
 
-  override def remove(elem: A): Option[A] = {
+  override def remove(elem: A): Boolean = {
     val e = table.removeEntry(elem)
-    if (e eq null) None
+    if (e eq null) false
     else {
       if (e.earlier eq null) firstEntry = e.later
       else e.earlier.later = e.later
       if (e.later eq null) lastEntry = e.earlier
       else e.later.earlier = e.earlier
       e.earlier = null // Null references to prevent nepotism
       e.later = null
-      Some(e.key)
+      true
     }
   }
 

src/library/scala/collection/mutable/Set.scala

@@ -62,8 +62,8 @@ trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]]
     else remove(elem)
   }
 
-  def remove(elem: A): Option[A] = {
-    val res = get(elem)
+  def remove(elem: A): Boolean = {
+    val res = contains(elem)
     coll -= elem
     res
   }

test/files/run/hashsetremove.scala

@@ -4,10 +4,10 @@ import scala.collection.mutable.HashSet
 object Test extends App {
   val h = new HashSet[Int]
   h += 1
-  assert(h.remove(0) == None)
+  assert(!h.remove(0))
   assert(h(1))
-  assert(h.remove(1) == Some(1))
+  assert(h.remove(1))
   assert(!h(1))
-  assert(h.remove(1) == None)
+  assert(!h.remove(1))
   assert(!h(1))
  }