4 files changed, 50 insertions, 37 deletions
diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index 334377e838..a6f0fa9e78 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -352,23 +352,23 @@ object Predef extends LowPriorityImplicits with DeprecatedPredef {
 
   // "Autoboxing" and "Autounboxing" ---------------------------------------------------
 
-  implicit def byte2Byte(x: Byte)           = java.lang.Byte.valueOf(x)
-  implicit def short2Short(x: Short)        = java.lang.Short.valueOf(x)
-  implicit def char2Character(x: Char)      = java.lang.Character.valueOf(x)
-  implicit def int2Integer(x: Int)          = java.lang.Integer.valueOf(x)
-  implicit def long2Long(x: Long)           = java.lang.Long.valueOf(x)
-  implicit def float2Float(x: Float)        = java.lang.Float.valueOf(x)
-  implicit def double2Double(x: Double)     = java.lang.Double.valueOf(x)
-  implicit def boolean2Boolean(x: Boolean)  = java.lang.Boolean.valueOf(x)
-
-  implicit def Byte2byte(x: java.lang.Byte): Byte             = x.byteValue
-  implicit def Short2short(x: java.lang.Short): Short         = x.shortValue
-  implicit def Character2char(x: java.lang.Character): Char   = x.charValue
-  implicit def Integer2int(x: java.lang.Integer): Int         = x.intValue
-  implicit def Long2long(x: java.lang.Long): Long             = x.longValue
-  implicit def Float2float(x: java.lang.Float): Float         = x.floatValue
-  implicit def Double2double(x: java.lang.Double): Double     = x.doubleValue
-  implicit def Boolean2boolean(x: java.lang.Boolean): Boolean = x.booleanValue
+  implicit def byte2Byte(x: Byte): java.lang.Byte             = x.asInstanceOf[java.lang.Byte]
+  implicit def short2Short(x: Short): java.lang.Short         = x.asInstanceOf[java.lang.Short]
+  implicit def char2Character(x: Char): java.lang.Character   = x.asInstanceOf[java.lang.Character]
+  implicit def int2Integer(x: Int): java.lang.Integer         = x.asInstanceOf[java.lang.Integer]
+  implicit def long2Long(x: Long): java.lang.Long             = x.asInstanceOf[java.lang.Long]
+  implicit def float2Float(x: Float): java.lang.Float         = x.asInstanceOf[java.lang.Float]
+  implicit def double2Double(x: Double): java.lang.Double     = x.asInstanceOf[java.lang.Double]
+  implicit def boolean2Boolean(x: Boolean): java.lang.Boolean = x.asInstanceOf[java.lang.Boolean]
+
+  implicit def Byte2byte(x: java.lang.Byte): Byte             = x.asInstanceOf[Byte]
+  implicit def Short2short(x: java.lang.Short): Short         = x.asInstanceOf[Short]
+  implicit def Character2char(x: java.lang.Character): Char   = x.asInstanceOf[Char]
+  implicit def Integer2int(x: java.lang.Integer): Int         = x.asInstanceOf[Int]
+  implicit def Long2long(x: java.lang.Long): Long             = x.asInstanceOf[Long]
+  implicit def Float2float(x: java.lang.Float): Float         = x.asInstanceOf[Float]
+  implicit def Double2double(x: java.lang.Double): Double     = x.asInstanceOf[Double]
+  implicit def Boolean2boolean(x: java.lang.Boolean): Boolean = x.asInstanceOf[Boolean]
 
   // Type Constraints --------------------------------------------------------------
 
diff --git a/src/library/scala/collection/convert/WrapAsScala.scala b/src/library/scala/collection/convert/WrapAsScala.scala
index 7332b71af1..a96cccc6ed 100644
--- a/src/library/scala/collection/convert/WrapAsScala.scala
+++ b/src/library/scala/collection/convert/WrapAsScala.scala
@@ -176,14 +176,14 @@ trait WrapAsScala {
 
   /**
    * Implicitly converts a Java `Dictionary` to a Scala mutable
-   * `Map[String, String]`.
+   * `Map`.
    *
-   * The returned Scala `Map[String, String]` is backed by the provided Java
+   * The returned Scala `Map` 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 p The Dictionary to be converted.
-   * @return  A Scala mutable Map[String, String] view of the argument.
+   * @return  A Scala mutable Map view of the argument.
    */
   implicit def dictionaryAsScalaMap[A, B](p: ju.Dictionary[A, B]): mutable.Map[A, B] = p match {
     case null                       => null
diff --git a/src/library/scala/ref/SoftReference.scala b/src/library/scala/ref/SoftReference.scala
index e4ce667981..5e60f00788 100644
--- a/src/library/scala/ref/SoftReference.scala
+++ b/src/library/scala/ref/SoftReference.scala
@@ -20,6 +20,19 @@ class SoftReference[+T <: AnyRef](value : T, queue : ReferenceQueue[T]) extends
 }
 
 /**
+ *  A companion object that implements an extractor for `SoftReference` values
+ *  @author Rebecca Claire Murphy
+ */
+object SoftReference {
+
+  /** Creates a `SoftReference` pointing to `value` */
+  def apply[T <: AnyRef](value: T) = new SoftReference(value)
+
+  /** Optionally returns the referenced value, or `None` if that value no longer exists */
+  def unapply[T <: AnyRef](sr: SoftReference[T]): Option[T] = Option(sr.underlying.get)
+}
+
+/**
  *  @author Philipp Haller
  */
 private class SoftReferenceWithWrapper[T <: AnyRef](value: T, queue: ReferenceQueue[T], val wrapper: SoftReference[T])
diff --git a/src/library/scala/sys/SystemProperties.scala b/src/library/scala/sys/SystemProperties.scala
index 3ee4f6c708..4d1d8f740f 100644
--- a/src/library/scala/sys/SystemProperties.scala
+++ b/src/library/scala/sys/SystemProperties.scala
@@ -69,24 +69,24 @@ object SystemProperties {
   def exclusively[T](body: => T) = this synchronized body
 
   implicit def systemPropertiesToCompanion(p: SystemProperties): SystemProperties.type = this
-  private lazy val propertyHelp = mutable.Map[String, String]()
-  private def addHelp[P <: Prop[_]](p: P, helpText: String): P = {
-    propertyHelp(p.key) = helpText
-    p
+
+  private final val HeadlessKey            = "java.awt.headless"
+  private final val PreferIPv4StackKey     = "java.net.preferIPv4Stack"
+  private final val PreferIPv6AddressesKey = "java.net.preferIPv6Addresses"
+  private final val NoTraceSuppressionKey  = "scala.control.noTraceSuppression"
+
+  def help(key: String): String = key match {
+    case HeadlessKey            => "system should not utilize a display device"
+    case PreferIPv4StackKey     => "system should prefer IPv4 sockets"
+    case PreferIPv6AddressesKey => "system should prefer IPv6 addresses"
+    case NoTraceSuppressionKey  => "scala should not suppress any stack trace creation"
+    case _                      => ""
   }
-  private def bool(key: String, helpText: String): BooleanProp = addHelp[BooleanProp](
-    if (key startsWith "java.") BooleanProp.valueIsTrue(key) else BooleanProp.keyExists(key),
-    helpText
-  )
-  def help(key: String) = propertyHelp.getOrElse(key, "")
-
-  // Todo: bring some sanity to the intersection of system properties aka "mutable
-  // state shared by everyone and everything" and the reality that there is no other
-  // mechanism for accomplishing some things on the jvm.
-  lazy val headless            = bool("java.awt.headless", "system should not utilize a display device")
-  lazy val preferIPv4Stack     = bool("java.net.preferIPv4Stack", "system should prefer IPv4 sockets")
-  lazy val preferIPv6Addresses = bool("java.net.preferIPv6Addresses", "system should prefer IPv6 addresses")
-  lazy val noTraceSuppression  = bool("scala.control.noTraceSuppression", "scala should not suppress any stack trace creation")
+
+  lazy val headless: BooleanProp            = BooleanProp.keyExists(HeadlessKey)
+  lazy val preferIPv4Stack: BooleanProp     = BooleanProp.keyExists(PreferIPv4StackKey)
+  lazy val preferIPv6Addresses: BooleanProp = BooleanProp.keyExists(PreferIPv6AddressesKey)
+  lazy val noTraceSuppression: BooleanProp  = BooleanProp.valueIsTrue(NoTraceSuppressionKey)
   @deprecated("Use noTraceSuppression", "2.12.0")
   def noTraceSupression        = noTraceSuppression
 }