Overhaul of JavaConver{sions,ters}.

Initially motivated by SI-5580, then just motivated.  I broke up
the opaquely named JavaConversions and JavaConverters into the following
traits encapsulating some permutation of

  { to java, to scala, bidirectional }
  { wrappers, decorators }

I named everything consistently in terms of either Wrappers
or Decorators.  Decorators install those asJava/asScala methods
onto collections of the right kind; Wrappers hide the process.

JavaConversions then reduces to an object which (ill-advisedly)
extends both WrapAsJava and WrapAsScala.  And JavaConverters is
an object extending DecorateAsScala and DecorateAsJava.  However
other more clearly named vals exist in the newly created
scala.collection.convert package object.

  val decorateAsJava  = new DecorateAsJava { }
  val decorateAsScala = new DecorateAsScala { }
  val decorateAll     = new DecorateAsJava with DecorateAsScala { }
  val wrapAsJava      = new WrapAsJava { }
  val wrapAsScala     = new WrapAsScala { }
  val wrapAll         = new WrapAsJava with WrapAsScala { }

So for instance to import asScala decorators, and only those:

  scala> import scala.collection.convert.decorateAsScala._
  import scala.collection.convert.decorateAsScala._

  scala> new java.util.ArrayList[String].asScala groupBy (x => x)
  res0: scala.collection.immutable.Map[String,scala.collection.mutable.Buffer[String]] = Map()

I propose we put those vals or a subset of them in the scala
package object rather than way down in scala.collection.convert.

1 files changed, 45 insertions, 838 deletions

diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala
index 50919e506a..75ab3f28f5 100644
--- a/src/library/scala/collection/JavaConversions.scala
+++ b/src/library/scala/collection/JavaConversions.scala
@@ -8,6 +8,9 @@
 
 package scala.collection
 
+import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc }
+import convert._
+
 /**   A collection of implicit conversions supporting interoperability between
  *    Scala and Java collections.
  *
@@ -46,877 +49,81 @@ package scala.collection
  *  @author Martin Odersky
  *  @since  2.8
  */
-object JavaConversions {
+object JavaConversions extends WrapAsScala with WrapAsJava {
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type ConcurrentMapWrapper[A, B]  = Wrappers.ConcurrentMapWrapper[A, B]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type DictionaryWrapper[A, B]     = Wrappers.DictionaryWrapper[A, B]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type IterableWrapper[A]          = Wrappers.IterableWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type IteratorWrapper[A]          = Wrappers.IteratorWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JCollectionWrapper[A]       = Wrappers.JCollectionWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JConcurrentMapWrapper[A, B] = Wrappers.JConcurrentMapWrapper[A, B]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JDictionaryWrapper[A, B]    = Wrappers.JDictionaryWrapper[A, B]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JEnumerationWrapper[A]      = Wrappers.JEnumerationWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JIterableWrapper[A]         = Wrappers.JIterableWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JIteratorWrapper[A]         = Wrappers.JIteratorWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JListWrapper[A]             = Wrappers.JListWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JMapWrapper[A, B]           = Wrappers.JMapWrapper[A, B]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JPropertiesWrapper          = Wrappers.JPropertiesWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type JSetWrapper[A]              = Wrappers.JSetWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type MapWrapper[A, B]            = Wrappers.MapWrapper[A, B]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type MutableBufferWrapper[A]     = Wrappers.MutableBufferWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type MutableMapWrapper[A, B]     = Wrappers.MutableMapWrapper[A, B]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type MutableSeqWrapper[A]        = Wrappers.MutableSeqWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type MutableSetWrapper[A]        = Wrappers.MutableSetWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type SeqWrapper[A]               = Wrappers.SeqWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type SetWrapper[A]               = Wrappers.SetWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") type ToIteratorWrapper[A]        = Wrappers.ToIteratorWrapper[A]
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val DictionaryWrapper            = Wrappers.DictionaryWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val IterableWrapper              = Wrappers.IterableWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val IteratorWrapper              = Wrappers.IteratorWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JCollectionWrapper           = Wrappers.JCollectionWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JConcurrentMapWrapper        = Wrappers.JConcurrentMapWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JDictionaryWrapper           = Wrappers.JDictionaryWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JEnumerationWrapper          = Wrappers.JEnumerationWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JIterableWrapper             = Wrappers.JIterableWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JIteratorWrapper             = Wrappers.JIteratorWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JListWrapper                 = Wrappers.JListWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JMapWrapper                  = Wrappers.JMapWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JPropertiesWrapper           = Wrappers.JPropertiesWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val JSetWrapper                  = Wrappers.JSetWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val MutableBufferWrapper         = Wrappers.MutableBufferWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val MutableMapWrapper            = Wrappers.MutableMapWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val MutableSeqWrapper            = Wrappers.MutableSeqWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val MutableSetWrapper            = Wrappers.MutableSetWrapper
+  @deprecated("Use a member of scala.collection.convert.Wrappers", "2.10.0") val SeqWrapper                   = Wrappers.SeqWrapper
+
   // Note to implementors: the cavalcade of deprecated methods herein should
   // serve as a warning to any who follow: don't overload implicit methods.
 
-  import java.{ lang => jl, util => ju }
-  import java.util.{ concurrent => juc }
-
-  // Scala => Java
-
-  /**
-   * Implicitly converts a Scala Iterator to a Java Iterator.
-   * The returned Java Iterator is backed by the provided Scala
-   * Iterator and any side-effects of using it via the Java interface will
-   * be visible via the Scala interface and vice versa.
-   *
-   * If the Scala Iterator was previously obtained from an implicit or
-   * explicit call of `asIterator(java.util.Iterator)` then the original
-   * Java Iterator will be returned.
-   *
-   * @param i The Iterator to be converted.
-   * @return A Java Iterator view of the argument.
-   */
-  implicit def asJavaIterator[A](it: Iterator[A]): ju.Iterator[A] = it match {
-    case JIteratorWrapper(wrapped) => wrapped.asInstanceOf[ju.Iterator[A]]
-    case _ => IteratorWrapper(it)
-  }
-
-  /**
-   * Implicitly converts a Scala Iterator to a Java Enumeration.
-   * The returned Java Enumeration is backed by the provided Scala
-   * Iterator and any side-effects of using it via the Java interface will
-   * be visible via the Scala interface and vice versa.
-   *
-   * If the Scala Iterator was previously obtained from an implicit or
-   * explicit call of `asIterator(java.util.Enumeration)` then the
-   * original Java Enumeration will be returned.
-   *
-   * @param i The Iterator to be converted.
-   * @return A Java Enumeration view of the argument.
-   */
-  implicit def asJavaEnumeration[A](it: Iterator[A]): ju.Enumeration[A] = it match {
-    case JEnumerationWrapper(wrapped) => wrapped.asInstanceOf[ju.Enumeration[A]]
-    case _ => IteratorWrapper(it)
-  }
-
-  /**
-   * Implicitly converts a Scala Iterable to a Java Iterable.
-   * The returned Java Iterable is backed by the provided Scala
-   * Iterable and any side-effects of using it via the Java interface will
-   * be visible via the Scala interface and vice versa.
-   *
-   * If the Scala Iterable was previously obtained from an implicit or
-   * explicit call of `asIterable(java.lang.Iterable)` then the original
-   * Java Iterable will be returned.
-   *
-   * @param i The Iterable to be converted.
-   * @return A Java Iterable view of the argument.
-   */
-  implicit def asJavaIterable[A](i: Iterable[A]): jl.Iterable[A] = i match {
-    case JIterableWrapper(wrapped) => wrapped.asInstanceOf[jl.Iterable[A]]
-    case _ => IterableWrapper(i)
-  }
-
-  /**
-   * Implicitly converts a Scala Iterable to an immutable Java
-   * Collection.
-   *
-   * If the Scala Iterable was previously obtained from an implicit or
-   * explicit call of `asSizedIterable(java.util.Collection)` then the original
-   * Java Collection will be returned.
-   *
-   * @param i The SizedIterable to be converted.
-   * @return A Java Collection view of the argument.
-   */
-  implicit def asJavaCollection[A](it: Iterable[A]): ju.Collection[A] = it match {
-    case JCollectionWrapper(wrapped) => wrapped.asInstanceOf[ju.Collection[A]]
-    case _ => new IterableWrapper(it)
-  }
-
-  /**
-   * Implicitly converts a Scala mutable Buffer to a Java List.
-   * The returned Java List is backed by the provided Scala
-   * Buffer and any side-effects of using it via the Java interface will
-   * be visible via the Scala interface and vice versa.
-   *
-   * If the Scala Buffer was previously obtained from an implicit or
-   * explicit call of `asBuffer(java.util.List)` then the original
-   * Java List will be returned.
-   *
-   * @param b The Buffer to be converted.
-   * @return A Java List view of the argument.
-   */
-  implicit def bufferAsJavaList[A](b: mutable.Buffer[A]): ju.List[A] = b match {
-    case JListWrapper(wrapped) => wrapped
-    case _ => new MutableBufferWrapper(b)
-  }
   @deprecated("use bufferAsJavaList instead", "2.9.0")
   def asJavaList[A](b : mutable.Buffer[A]): ju.List[A] = bufferAsJavaList[A](b)
 
-  /**
-   * Implicitly converts a Scala mutable Seq to a Java List.
-   * The returned Java List is backed by the provided Scala
-   * Seq and any side-effects of using it via the Java interface will
-   * be visible via the Scala interface and vice versa.
-   *
-   * If the Scala Seq was previously obtained from an implicit or
-   * explicit call of `asSeq(java.util.List)` then the original
-   * Java List will be returned.
-   *
-   * @param b The Seq to be converted.
-   * @return A Java List view of the argument.
-   */
-  implicit def mutableSeqAsJavaList[A](seq: mutable.Seq[A]): ju.List[A] = seq match {
-    case JListWrapper(wrapped) => wrapped
-    case _ => new MutableSeqWrapper(seq)
-  }
   @deprecated("use mutableSeqAsJavaList instead", "2.9.0")
   def asJavaList[A](b : mutable.Seq[A]): ju.List[A] = mutableSeqAsJavaList[A](b)
 
-  /**
-   * Implicitly converts a Scala Seq to a Java List.
-   * The returned Java List is backed by the provided Scala
-   * Seq and any side-effects of using it via the Java interface will
-   * be visible via the Scala interface and vice versa.
-   *
-   * If the Scala Seq was previously obtained from an implicit or
-   * explicit call of `asSeq(java.util.List)` then the original
-   * Java List will be returned.
-   *
-   * @param b The Seq to be converted.
-   * @return A Java List view of the argument.
-   */
-  implicit def seqAsJavaList[A](seq: Seq[A]): ju.List[A] = seq match {
-    case JListWrapper(wrapped) => wrapped.asInstanceOf[ju.List[A]]
-    case _ => new SeqWrapper(seq)
-  }
-
   @deprecated("use seqAsJavaList instead", "2.9.0")
   def asJavaList[A](b : Seq[A]): ju.List[A] = seqAsJavaList[A](b)
 
-  /**
-   * Implicitly converts a Scala mutable Set to a Java Set.
-   * The returned Java Set is backed by the provided Scala
-   * Set and any side-effects of using it via the Java interface will
-   * be visible via the Scala interface and vice versa.
-   *
-   * If the Scala Set was previously obtained from an implicit or
-   * explicit call of `asSet(java.util.Set)` then the original
-   * Java Set will be returned.
-   *
-   * @param s The Set to be converted.
-   * @return A Java Set view of the argument.
-   */
-  implicit def mutableSetAsJavaSet[A](s: mutable.Set[A]): ju.Set[A] = s match {
-    case JSetWrapper(wrapped) => wrapped
-    case _ => new MutableSetWrapper(s)
-  }
-
   @deprecated("use mutableSetAsJavaSet instead", "2.9.0")
   def asJavaSet[A](s : mutable.Set[A]): ju.Set[A] = mutableSetAsJavaSet[A](s)
 
-  /**
-   * Implicitly converts a Scala Set to a Java Set.
-   * The returned Java Set is backed by the provided Scala
-   * Set and any side-effects of using it via the Java interface will
-   * be visible via the Scala interface and vice versa.
-   *
-   * If the Scala Set was previously obtained from an implicit or
-   * explicit call of asSet(java.util.Set) then the original
-   * Java Set will be returned.
-   *
-   * @param s The Set to be converted.
-   * @return A Java Set view of the argument.
-   */
-  implicit def setAsJavaSet[A](s: Set[A]): ju.Set[A] = s match {
-    case JSetWrapper(wrapped) => wrapped
-    case _ => new SetWrapper(s)
-  }
-
   @deprecated("use setAsJavaSet instead", "2.9.0")
   def asJavaSet[A](s: Set[A]): ju.Set[A] = setAsJavaSet[A](s)
 
-  /**
-   * Implicitly converts a Scala mutable Map to a Java Map.
-   * The returned Java Map is backed by the provided Scala
-   * Map and any side-effects of using it via the Java interface will
-   * be visible via the Scala interface and vice versa.
-   *
-   * If the Scala Map was previously obtained from an implicit or
-   * explicit call of `asMap(java.util.Map)` then the original
-   * Java Map will be returned.
-   *
-   * @param m The Map to be converted.
-   * @return A Java Map view of the argument.
-   */
-  implicit def mutableMapAsJavaMap[A, B](m: mutable.Map[A, B]): ju.Map[A, B] = m match {
-    //case JConcurrentMapWrapper(wrapped) => wrapped
-    case JMapWrapper(wrapped) => wrapped
-    case _ => new MutableMapWrapper(m)
-  }
-
   @deprecated("use mutableMapAsJavaMap instead", "2.9.0")
   def asJavaMap[A, B](m : mutable.Map[A, B]): ju.Map[A, B] = mutableMapAsJavaMap[A, B](m)
 
-  /**
-   * Implicitly converts a Scala mutable `Map` to a Java `Dictionary`.
-   *
-   * The returned Java `Dictionary` is backed by the provided Scala
-   * `Dictionary` and any side-effects of using it via the Java interface
-   * will be visible via the Scala interface and vice versa.
-   *
-   * If the Scala `Dictionary` was previously obtained from an implicit or
-   * explicit call of `asMap(java.util.Dictionary)` then the original
-   * Java Dictionary will be returned.
-   *
-   * @param m The `Map` to be converted.
-   * @return A Java `Dictionary` view of the argument.
-   */
-  implicit def asJavaDictionary[A, B](m: mutable.Map[A, B]): ju.Dictionary[A, B] = m match {
-    //case JConcurrentMapWrapper(wrapped) => wrapped
-    case JDictionaryWrapper(wrapped) => wrapped
-    case _ => new DictionaryWrapper(m)
-  }
-
-  /**
-   * Implicitly converts a Scala `Map` to a Java `Map`.
-   *
-   * The returned Java `Map` is backed by the provided Scala `Map` and
-   * any side-effects of using it via the Java interface will be visible
-   * via the Scala interface and vice versa.
-   *
-   * If the Scala `Map` was previously obtained from an implicit or
-   * explicit call of `asMap(java.util.Map)` then the original
-   * Java `Map` will be returned.
-   *
-   * @param m The `Map` to be converted.
-   * @return A Java `Map` view of the argument.
-   */
-  implicit def mapAsJavaMap[A, B](m: Map[A, B]): ju.Map[A, B] = m match {
-    //case JConcurrentMapWrapper(wrapped) => wrapped
-    case JMapWrapper(wrapped) => wrapped.asInstanceOf[ju.Map[A, B]]
-    case _ => new MapWrapper(m)
-  }
-
   @deprecated("use mapAsJavaMap instead", "2.9.0")
   def asJavaMap[A, B](m : Map[A, B]): ju.Map[A, B] = mapAsJavaMap[A, B](m)
 
-  /**
-   * Implicitly converts a Scala mutable `ConcurrentMap` to a Java
-   * `ConcurrentMap`.
-   *
-   * The returned Java `ConcurrentMap` is backed by the provided Scala
-   * `ConcurrentMap` and any side-effects of using it via the Java interface
-   * will be visible via the Scala interface and vice versa.
-   *
-   * If the Scala `ConcurrentMap` was previously obtained from an implicit or
-   * explicit call of `asConcurrentMap(java.util.concurrect.ConcurrentMap)`
-   * then the original Java ConcurrentMap will be returned.
-   *
-   * @param m The `ConcurrentMap` to be converted.
-   * @return A Java `ConcurrentMap` view of the argument.
-   */
-  implicit def asJavaConcurrentMap[A, B](m: mutable.ConcurrentMap[A, B]): juc.ConcurrentMap[A, B] = m match {
-    case JConcurrentMapWrapper(wrapped) => wrapped
-    case _ => new ConcurrentMapWrapper(m)
-  }
-
-  // Java => Scala
-
-  /**
-   * Implicitly converts a Java `Iterator` to a Scala `Iterator`.
-   *
-   * The returned Scala `Iterator` is backed by the provided Java `Iterator`
-   * and any side-effects of using it via the Scala interface will be visible
-   * via the Java interface and vice versa.
-   *
-   * If the Java `Iterator` was previously obtained from an implicit or
-   * explicit call of `asIterator(scala.collection.Iterator)` then the
-   * original Scala `Iterator` will be returned.
-   *
-   * @param i The `Iterator` to be converted.
-   * @return A Scala `Iterator` view of the argument.
-   */
-  implicit def asScalaIterator[A](it: ju.Iterator[A]): Iterator[A] = it match {
-    case IteratorWrapper(wrapped) => wrapped
-    case _ => JIteratorWrapper(it)
-  }
-
-  /**
-   * Implicitly converts a Java Enumeration to a Scala Iterator.
-   * The returned Scala Iterator is backed by the provided Java
-   * Enumeration and any side-effects of using it via the Scala interface will
-   * be visible via the Java interface and vice versa.
-   *
-   * If the Java Enumeration was previously obtained from an implicit or
-   * explicit call of `enumerationAsScalaIterator(scala.collection.Iterator)`
-   * then the original Scala Iterator will be returned.
-   *
-   * @param i The Enumeration to be converted.
-   * @return A Scala Iterator view of the argument.
-   */
-  implicit def enumerationAsScalaIterator[A](i: ju.Enumeration[A]): Iterator[A] = i match {
-    case IteratorWrapper(wrapped) => wrapped
-    case _ => JEnumerationWrapper(i)
-  }
-
-  /**
-   * Implicitly converts a Java `Iterable` to a Scala `Iterable`.
-   *
-   * The returned Scala `Iterable` is backed by the provided Java `Iterable`
-   * and any side-effects of using it via the Scala interface will be visible
-   * via the Java interface and vice versa.
-   *
-   * If the Java `Iterable` was previously obtained from an implicit or
-   * explicit call of `iterableAsScalaIterable(scala.collection.Iterable)`
-   * then the original Scala Iterable will be returned.
-   *
-   * @param i The Iterable to be converted.
-   * @return A Scala Iterable view of the argument.
-   */
-  implicit def iterableAsScalaIterable[A](i: jl.Iterable[A]): Iterable[A] = i match {
-    case IterableWrapper(wrapped) => wrapped
-    case _ => JIterableWrapper(i)
-  }
-
   @deprecated("use iterableAsScalaIterable instead", "2.9.0")
   def asScalaIterable[A](i : jl.Iterable[A]): Iterable[A] = iterableAsScalaIterable[A](i)
 
-  /**
-   * Implicitly converts a Java `Collection` to an Scala `Iterable`.
-   *
-   * If the Java `Collection` was previously obtained from an implicit or
-   * explicit call of `collectionAsScalaIterable(scala.collection.SizedIterable)`
-   * then the original Scala `Iterable` will be returned.
-   *
-   * @param i The Collection to be converted.
-   * @return A Scala Iterable view of the argument.
-   */
-  implicit def collectionAsScalaIterable[A](i: ju.Collection[A]): Iterable[A] = i match {
-    case IterableWrapper(wrapped) => wrapped
-    case _ => JCollectionWrapper(i)
-  }
   @deprecated("use collectionAsScalaIterable instead", "2.9.0")
   def asScalaIterable[A](i : ju.Collection[A]): Iterable[A] = collectionAsScalaIterable[A](i)
 
-  /**
-   * Implicitly converts a Java `List` to a Scala mutable `Buffer`.
-   *
-   * The returned Scala `Buffer` is backed by the provided Java `List`
-   * and any side-effects of using it via the Scala interface will
-   * be visible via the Java interface and vice versa.
-   *
-   * If the Java `List` was previously obtained from an implicit or
-   * explicit call of `asScalaBuffer(scala.collection.mutable.Buffer)`
-   * then the original Scala `Buffer` will be returned.
-   *
-   * @param l The `List` to be converted.
-   * @return A Scala mutable `Buffer` view of the argument.
-   */
-  implicit def asScalaBuffer[A](l: ju.List[A]): mutable.Buffer[A] = l match {
-    case MutableBufferWrapper(wrapped) => wrapped
-    case _ =>new JListWrapper(l)
-  }
-
-  /**
-   * Implicitly converts a Java Set to a Scala mutable Set.
-   * The returned Scala Set is backed by the provided Java
-   * Set and any side-effects of using it via the Scala interface will
-   * be visible via the Java interface and vice versa.
-   *
-   * If the Java Set was previously obtained from an implicit or
-   * explicit call of `asScalaSet(scala.collection.mutable.Set)` then
-   * the original Scala Set will be returned.
-   *
-   * @param s The Set to be converted.
-   * @return A Scala mutable Set view of the argument.
-   */
-  implicit def asScalaSet[A](s: ju.Set[A]): mutable.Set[A] = s match {
-    case MutableSetWrapper(wrapped) => wrapped
-    case _ =>new JSetWrapper(s)
-  }
-
-  /**
-   * Implicitly converts a Java `Map` to a Scala mutable `Map`.
-   *
-   * The returned Scala `Map` is backed by the provided Java `Map` and any
-   * side-effects of using it via the Scala interface will be visible via
-   * the Java interface and vice versa.
-   *
-   * If the Java `Map` was previously obtained from an implicit or
-   * explicit call of `mapAsScalaMap(scala.collection.mutable.Map)` then
-   * the original Scala Map will be returned.
-   *
-   * @param m The Map to be converted.
-   * @return A Scala mutable Map view of the argument.
-   */
-  implicit def mapAsScalaMap[A, B](m: ju.Map[A, B]): mutable.Map[A, B] = m match {
-    //case ConcurrentMapWrapper(wrapped) => wrapped
-    case MutableMapWrapper(wrapped) => wrapped
-    case _ => new JMapWrapper(m)
-  }
-
   @deprecated("use mapAsScalaMap instead", "2.9.0")
   def asScalaMap[A, B](m: ju.Map[A, B]): mutable.Map[A, B] = mapAsScalaMap[A, B](m)
 
-  /**
-   * Implicitly converts a Java ConcurrentMap to a Scala mutable ConcurrentMap.
-   * The returned Scala ConcurrentMap is backed by the provided Java
-   * ConcurrentMap and any side-effects of using it via the Scala interface will
-   * be visible via the Java interface and vice versa.
-   *
-   * If the Java ConcurrentMap was previously obtained from an implicit or
-   * explicit call of `asConcurrentMap(scala.collection.mutable.ConcurrentMap)`
-   * then the original Scala ConcurrentMap will be returned.
-   *
-   * @param m The ConcurrentMap to be converted.
-   * @return A Scala mutable ConcurrentMap view of the argument.
-   */
-  implicit def asScalaConcurrentMap[A, B](m: juc.ConcurrentMap[A, B]): mutable.ConcurrentMap[A, B] = m match {
-    case cmw: ConcurrentMapWrapper[a, b] => cmw.underlying
-    case _                               => new JConcurrentMapWrapper(m)
-  }
-
-  /**
-   * Implicitly converts a Java `Dictionary` to a Scala mutable
-   * `Map[String, String]`.
-   *
-   * The returned Scala `Map[String, String]` is backed by the provided Java
-   * `Dictionary` and any side-effects of using it via the Scala interface
-   * will be visible via the Java interface and vice versa.
-   *
-   * @param m The Dictionary to be converted.
-   * @return A Scala mutable Map[String, String] view of the argument.
-   */
-  implicit def dictionaryAsScalaMap[A, B](p: ju.Dictionary[A, B]): mutable.Map[A, B] = p match {
-    case DictionaryWrapper(wrapped) => wrapped
-    case _ => new JDictionaryWrapper(p)
-  }
-
-  /**
-   * Implicitly converts a Java `Properties` to a Scala `mutable Map[String, String]`.
-   *
-   * The returned Scala `Map[String, String]` is backed by the provided Java
-   * `Properties` and any side-effects of using it via the Scala interface
-   * will be visible via the Java interface and vice versa.
-   *
-   * @param m The Properties to be converted.
-   * @return A Scala mutable Map[String, String] view of the argument.
-   */
-  implicit def propertiesAsScalaMap(p: ju.Properties): mutable.Map[String, String] = p match {
-    case _ => new JPropertiesWrapper(p)
-  }
-
   @deprecated("use propertiesAsScalaMap instead", "2.9.0")
   def asScalaMap(p: ju.Properties): mutable.Map[String, String] = propertiesAsScalaMap(p)
-
-  // Private implementations (shared by JavaConverters) ...
-
-  trait IterableWrapperTrait[A] extends ju.AbstractCollection[A] {
-    val underlying: Iterable[A]
-    def size = underlying.size
-    override def iterator = IteratorWrapper(underlying.iterator)
-    override def isEmpty = underlying.isEmpty
-  }
-
-  case class IteratorWrapper[A](underlying: Iterator[A])
-  extends ju.Iterator[A] with ju.Enumeration[A] {
-    def hasNext = underlying.hasNext
-    def next() = underlying.next
-    def hasMoreElements = underlying.hasNext
-    def nextElement() = underlying.next
-    def remove() = throw new UnsupportedOperationException
-  }
-
-  class ToIteratorWrapper[A](underlying : Iterator[A]) {
-    def asJava = new IteratorWrapper(underlying)
-  }
-
-  case class JIteratorWrapper[A](underlying: ju.Iterator[A]) extends AbstractIterator[A] with Iterator[A] {
-    def hasNext = underlying.hasNext
-    def next() = underlying.next
-  }
-
-  case class JEnumerationWrapper[A](underlying: ju.Enumeration[A]) extends AbstractIterator[A] with Iterator[A] {
-    def hasNext = underlying.hasMoreElements
-    def next() = underlying.nextElement
-  }
-
-  case class IterableWrapper[A](underlying: Iterable[A])
-                extends ju.AbstractCollection[A]
-                   with IterableWrapperTrait[A] { }
-
-  case class JIterableWrapper[A](underlying: jl.Iterable[A]) extends AbstractIterable[A] with Iterable[A] {
-    def iterator = underlying.iterator
-    def newBuilder[B] = new mutable.ArrayBuffer[B]
-  }
-
-  case class JCollectionWrapper[A](underlying: ju.Collection[A]) extends AbstractIterable[A] with Iterable[A] {
-    def iterator = underlying.iterator
-    override def size = underlying.size
-    override def isEmpty = underlying.isEmpty
-    def newBuilder[B] = new mutable.ArrayBuffer[B]
-  }
-
-  case class SeqWrapper[A](underlying: Seq[A]) extends ju.AbstractList[A] with IterableWrapperTrait[A] {
-    def get(i: Int) = underlying(i)
-  }
-
-  case class MutableSeqWrapper[A](underlying: mutable.Seq[A])
-  extends ju.AbstractList[A] with IterableWrapperTrait[A] {
-    def get(i: Int) = underlying(i)
-    override def set(i: Int, elem: A) = {
-      val p = underlying(i)
-      underlying(i) = elem
-      p
-    }
-  }
-
-  case class MutableBufferWrapper[A](underlying: mutable.Buffer[A])
-  extends ju.AbstractList[A] with IterableWrapperTrait[A] {
-    def get(i: Int) = underlying(i)
-    override def set(i: Int, elem: A) = { val p = underlying(i); underlying(i) = elem; p }
-    override def add(elem: A) = { underlying append elem; true }
-    override def remove(i: Int) = underlying remove i
-  }
-
-  case class JListWrapper[A](val underlying: ju.List[A]) extends mutable.AbstractBuffer[A] with mutable.Buffer[A] {
-    def length = underlying.size
-    override def isEmpty = underlying.isEmpty
-    override def iterator: Iterator[A] = underlying.iterator
-    def apply(i: Int) = underlying.get(i)
-    def update(i: Int, elem: A) = underlying.set(i, elem)
-    def +=:(elem: A) = { underlying.subList(0, 0) add elem; this }
-    def +=(elem: A): this.type = { underlying add elem; this }
-    def insertAll(i: Int, elems: Traversable[A]) = {
-      val ins = underlying.subList(0, i)
-      elems.seq.foreach(ins.add(_))
-    }
-    def remove(i: Int) = underlying.remove(i)
-    def clear() = underlying.clear()
-    def result = this
-  }
-
-  class SetWrapper[A](underlying: Set[A]) extends ju.AbstractSet[A] {
-    self =>
-    def size = underlying.size
-    def iterator = new ju.Iterator[A] {
-      val ui = underlying.iterator
-      var prev: Option[A] = None
-      def hasNext = ui.hasNext
-      def next = { val e = ui.next; prev = Some(e); e }
-      def remove = prev match {
-        case Some(e) =>
-          underlying match {
-            case ms: mutable.Set[a] =>
-              ms remove e
-              prev = None
-            case _ =>
-              throw new UnsupportedOperationException("remove")
-          }
-        case _ =>
-          throw new IllegalStateException("next must be called at least once before remove")
-      }
-    }
-  }
-
-  case class MutableSetWrapper[A](underlying: mutable.Set[A]) extends SetWrapper[A](underlying) {
-    override def add(elem: A) = {
-      val sz = underlying.size
-      underlying += elem
-      sz < underlying.size
-    }
-    override def remove(elem: AnyRef) =
-      try underlying remove elem.asInstanceOf[A]
-      catch { case ex: ClassCastException => false }
-    override def clear() = underlying.clear()
-  }
-
-  case class JSetWrapper[A](underlying: ju.Set[A])
-  extends mutable.AbstractSet[A]
-     with mutable.Set[A]
-     with mutable.SetLike[A, JSetWrapper[A]] {
-
-    override def size = underlying.size
-
-    def iterator = underlying.iterator
-
-    def contains(elem: A): Boolean = underlying.contains(elem)
-
-    def +=(elem: A): this.type = { underlying add elem; this }
-    def -=(elem: A): this.type = { underlying remove elem; this }
-
-    override def add(elem: A): Boolean = underlying add elem
-    override def remove(elem: A): Boolean = underlying remove elem
-    override def clear() = underlying.clear()
-
-    override def empty = JSetWrapper(new ju.HashSet[A])
-  }
-
-  class MapWrapper[A, B](underlying: Map[A, B]) extends ju.AbstractMap[A, B] { self =>
-    override def size = underlying.size
-
-    override def get(key: AnyRef): B = try {
-      underlying get key.asInstanceOf[A] match {
-        case None => null.asInstanceOf[B]
-        case Some(v) => v
-      }
-    } catch {
-      case ex: ClassCastException => null.asInstanceOf[B]
-    }
-
-    override def entrySet: ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] {
-      def size = self.size
-
-      def iterator = new ju.Iterator[ju.Map.Entry[A, B]] {
-        val ui = underlying.iterator
-        var prev : Option[A] = None
-
-        def hasNext = ui.hasNext
-
-        def next() = {
-          val (k, v) = ui.next
-          prev = Some(k)
-          new ju.Map.Entry[A, B] {
-            def getKey = k
-            def getValue = v
-            def setValue(v1 : B) = self.put(k, v1)
-            override def hashCode = k.hashCode + v.hashCode
-            override def equals(other: Any) = other match {
-              case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue
-              case _ => false
-            }
-          }
-        }
-
-        def remove() {
-          prev match {
-            case Some(k) =>
-              underlying match {
-                case mm: mutable.Map[a, _] =>
-                  mm remove k
-                  prev = None
-                case _ =>
-                  throw new UnsupportedOperationException("remove")
-              }
-            case _ =>
-              throw new IllegalStateException("next must be called at least once before remove")
-          }
-        }
-      }
-    }
-  }
-
-  case class MutableMapWrapper[A, B](underlying: mutable.Map[A, B])
-  extends MapWrapper[A, B](underlying) {
-    override def put(k: A, v: B) = underlying.put(k, v) match {
-      case Some(v1) => v1
-      case None => null.asInstanceOf[B]
-    }
-
-    override def remove(k: AnyRef): B = try {
-      underlying remove k.asInstanceOf[A] match {
-        case None => null.asInstanceOf[B]
-        case Some(v) => v
-      }
-    } catch {
-      case ex: ClassCastException => null.asInstanceOf[B]
-    }
-
-    override def clear() = underlying.clear()
-  }
-
-  trait JMapWrapperLike[A, B, +Repr <: mutable.MapLike[A, B, Repr] with mutable.Map[A, B]]
-  extends mutable.Map[A, B] with mutable.MapLike[A, B, Repr] {
-    def underlying: ju.Map[A, B]
-
-    override def size = underlying.size
-
-    def get(k: A) = {
-      val v = underlying get k
-      if (v != null)
-        Some(v)
-      else if (underlying containsKey k)
-        Some(null.asInstanceOf[B])
-      else
-        None
-    }
-
-    def +=(kv: (A, B)): this.type = { underlying.put(kv._1, kv._2); this }
-    def -=(key: A): this.type = { underlying remove key; this }
-
-    override def put(k: A, v: B): Option[B] = {
-      val r = underlying.put(k, v)
-      if (r != null) Some(r) else None
-    }
-
-    override def update(k: A, v: B) { underlying.put(k, v) }
-
-    override def remove(k: A): Option[B] = {
-      val r = underlying remove k
-      if (r != null) Some(r) else None
-    }
-
-    def iterator: Iterator[(A, B)] = new AbstractIterator[(A, B)] {
-      val ui = underlying.entrySet.iterator
-      def hasNext = ui.hasNext
-      def next() = { val e = ui.next(); (e.getKey, e.getValue) }
-    }
-
-    override def clear() = underlying.clear()
-
-    override def empty: Repr = null.asInstanceOf[Repr]
-  }
-
-  case class JMapWrapper[A, B](val underlying : ju.Map[A, B])
-  extends mutable.AbstractMap[A, B] with JMapWrapperLike[A, B, JMapWrapper[A, B]] {
-    override def empty = JMapWrapper(new ju.HashMap[A, B])
-  }
-
-  class ConcurrentMapWrapper[A, B](override val underlying: mutable.ConcurrentMap[A, B])
-  extends MutableMapWrapper[A, B](underlying) with juc.ConcurrentMap[A, B] {
-
-    def putIfAbsent(k: A, v: B) = underlying.putIfAbsent(k, v) match {
-      case Some(v) => v
-      case None => null.asInstanceOf[B]
-    }
-
-    def remove(k: AnyRef, v: AnyRef) = try {
-      underlying.remove(k.asInstanceOf[A], v.asInstanceOf[B])
-    } catch {
-      case ex: ClassCastException =>
-        false
-    }
-
-    def replace(k: A, v: B): B = underlying.replace(k, v) match {
-      case Some(v) => v
-      case None => null.asInstanceOf[B]
-    }
-
-    def replace(k: A, oldval: B, newval: B) = underlying.replace(k, oldval, newval)
-  }
-
-  case class JConcurrentMapWrapper[A, B](val underlying: juc.ConcurrentMap[A, B])
-  extends mutable.AbstractMap[A, B] with JMapWrapperLike[A, B, JConcurrentMapWrapper[A, B]] with mutable.ConcurrentMap[A, B] {
-    override def get(k: A) = {
-      val v = underlying get k
-      if (v != null) Some(v)
-      else None
-    }
-
-    override def empty = new JConcurrentMapWrapper(new juc.ConcurrentHashMap[A, B])
-
-    def putIfAbsent(k: A, v: B): Option[B] = {
-      val r = underlying.putIfAbsent(k, v)
-      if (r != null) Some(r) else None
-    }
-
-    def remove(k: A, v: B): Boolean = underlying.remove(k, v)
-
-    def replace(k: A, v: B): Option[B] = {
-      val prev = underlying.replace(k, v)
-      if (prev != null) Some(prev) else None
-    }
-
-    def replace(k: A, oldvalue: B, newvalue: B): Boolean =
-      underlying.replace(k, oldvalue, newvalue)
-  }
-
-  case class DictionaryWrapper[A, B](underlying: mutable.Map[A, B])
-  extends ju.Dictionary[A, B] {
-    def size: Int = underlying.size
-    def isEmpty: Boolean = underlying.isEmpty
-    def keys: ju.Enumeration[A] = asJavaEnumeration(underlying.keysIterator)
-    def elements: ju.Enumeration[B] = asJavaEnumeration(underlying.valuesIterator)
-    def get(key: AnyRef) = try {
-      underlying get key.asInstanceOf[A] match {
-        case None => null.asInstanceOf[B]
-        case Some(v) => v
-      }
-    } catch {
-      case ex: ClassCastException => null.asInstanceOf[B]
-    }
-    def put(key: A, value: B): B = underlying.put(key, value) match {
-      case Some(v) => v
-      case None => null.asInstanceOf[B]
-    }
-    override def remove(key: AnyRef) = try {
-      underlying remove key.asInstanceOf[A] match {
-        case None => null.asInstanceOf[B]
-        case Some(v) => v
-      }
-    } catch {
-      case ex: ClassCastException => null.asInstanceOf[B]
-    }
-  }
-
-  case class JDictionaryWrapper[A, B](underlying: ju.Dictionary[A, B])
-  extends mutable.AbstractMap[A, B] with mutable.Map[A, B] {
-    override def size: Int = underlying.size
-
-    def get(k: A) = {
-      val v = underlying get k
-      if (v != null) Some(v) else None
-    }
-
-    def +=(kv: (A, B)): this.type = { underlying.put(kv._1, kv._2); this }
-    def -=(key: A): this.type = { underlying remove key; this }
-
-    override def put(k: A, v: B): Option[B] = {
-      val r = underlying.put(k, v)
-      if (r != null) Some(r) else None
-    }
-
-    override def update(k: A, v: B) { underlying.put(k, v) }
-
-    override def remove(k: A): Option[B] = {
-      val r = underlying remove k
-      if (r != null) Some(r) else None
-    }
-
-    def iterator = enumerationAsScalaIterator(underlying.keys) map (k => (k, underlying get k))
-
-    override def clear() = underlying.clear()
-  }
-
-  case class JPropertiesWrapper(underlying: ju.Properties)
-  extends mutable.AbstractMap[String, String]
-     with mutable.Map[String, String]
-     with mutable.MapLike[String, String, JPropertiesWrapper] {
-
-    override def size = underlying.size
-
-    def get(k: String) = {
-      val v = underlying get k
-      if (v != null) Some(v.asInstanceOf[String]) else None
-    }
-
-    def +=(kv: (String, String)): this.type = { underlying.put(kv._1, kv._2); this }
-    def -=(key: String): this.type = { underlying remove key; this }
-
-    override def put(k: String, v: String): Option[String] = {
-      val r = underlying.put(k, v)
-      if (r != null) Some(r.asInstanceOf[String]) else None
-    }
-
-    override def update(k: String, v: String) { underlying.put(k, v) }
-
-    override def remove(k: String): Option[String] = {
-      val r = underlying remove k
-      if (r != null) Some(r.asInstanceOf[String]) else None
-    }
-
-    def iterator: Iterator[(String, String)] = new AbstractIterator[(String, String)] {
-      val ui = underlying.entrySet.iterator
-      def hasNext = ui.hasNext
-      def next() = {
-        val e = ui.next()
-        (e.getKey.asInstanceOf[String], e.getValue.asInstanceOf[String])
-      }
-    }
-
-    override def clear() = underlying.clear()
-
-    override def empty = JPropertiesWrapper(new ju.Properties)
-
-    def getProperty(key: String) = underlying.getProperty(key)
-
-    def getProperty(key: String, defaultValue: String) =
-      underlying.getProperty(key, defaultValue)
-
-    def setProperty(key: String, value: String) =
-      underlying.setProperty(key, value)
-  }
 }