Add a slim version of OptionConverters for JS only

Author: haukeh

build.sbt

@@ -91,7 +91,7 @@ lazy val compat = new MultiScalaCrossProject(
           exclude[ReversedMissingMethodProblem]("scala.collection.compat.PackageShared.*"), // it's package-private
           exclude[Problem]("scala.collection.compat.*PreservingBuilder*")
         )
-      },
+      }
     )
     .jvmSettings(
       Test / unmanagedSourceDirectories += (ThisBuild / baseDirectory).value / "compat/src/test/scala-jvm",
@@ -104,7 +104,7 @@ lazy val compat = new MultiScalaCrossProject(
             jvmParent / "scala-2.11_2.12"
         }
       },
-      junit,
+      junit
     )
     .disablePlugins(ScalafixPlugin),
   _.jsSettings(
@@ -120,6 +120,15 @@ lazy val compat = new MultiScalaCrossProject(
       }
       Seq(s"$opt:$x->$y/")
     },
+    Compile / unmanagedSourceDirectories += {
+      val jsParent = (ThisBuild / baseDirectory).value / "compat/js/src/main"
+      CrossVersion.partialVersion(scalaVersion.value) match {
+        case Some((3, _) | (2, 13)) =>
+          jsParent / "scala-2.13"
+        case _ =>
+          jsParent / "scala-2.11_2.12"
+      }
+    },
     Test / fork := false // Scala.js cannot run forked tests
   ).jsEnablePlugins(ScalaJSJUnitPlugin),
   _.nativeSettings(

compat/js/src/main/scala-2.11_2.12/scala/jdk/OptionConverters.scala

@@ -0,0 +1,65 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.jdk
+
+import java.util.Optional
+
+/** This object provides extension methods that convert between Scala `Option` and Java `Optional`
+ * types.
+ *
+ * It differs from the JVM version as in it does not provide any conversions for the Optional primitive type
+ * wrappers which are available in the JDK but not in Scala-JS or Scala-Native.
+ *
+ * Scala `Option` is extended with a `toJava` method that creates a corresponding `Optional`.
+ *
+ * Java `Optional` is extended with a `toScala` method.
+ *
+ *
+ * Example usage:
+ *
+ * {{{
+ *   import scala.jdk.OptionConverters._
+ *   val a = Option("example").toJava      // Creates java.util.Optional[String] containing "example"
+ *   val b = (None: Option[String]).toJava // Creates an empty java.util.Optional[String]
+ *   val c = a.toScala                     // Back to Option("example")
+ *   val d = b.toScala                     // Back to None typed as Option[String]
+ * }}}
+ */
+object OptionConverters {
+
+  /** Provides conversions from Java `Optional` to Scala `Option` and specialized `Optional` types */
+  implicit class RichOptional[A](private val o: java.util.Optional[A]) extends AnyVal {
+
+    /** Convert a Java `Optional` to a Scala `Option` */
+    def toScala: Option[A] = if (o.isPresent) Some(o.get) else None
+
+    /** Convert a Java `Optional` to a Scala `Option` */
+    @deprecated("Use `toScala` instead", "2.13.0")
+    def asScala: Option[A] = if (o.isPresent) Some(o.get) else None
+  }
+
+  /** Provides conversions from Scala `Option` to Java `Optional` types */
+  implicit class RichOption[A](private val o: Option[A]) extends AnyVal {
+
+    /** Convert a Scala `Option` to a generic Java `Optional` */
+    def toJava: Optional[A] = o match {
+      case Some(a) => Optional.ofNullable(a); case _ => Optional.empty[A]
+    }
+
+    /** Convert a Scala `Option` to a generic Java `Optional` */
+    @deprecated("Use `toJava` instead", "2.13.0")
+    def asJava: Optional[A] = o match {
+      case Some(a) => Optional.ofNullable(a); case _ => Optional.empty[A]
+    }
+  }
+}

compat/src/test/scala-2.11_2.12/test/scala/jdk/OptionConvertersTest.scala

@@ -0,0 +1,55 @@
+package test.scala.jdk
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+import java.util.Optional
+import scala.jdk.OptionConverters._
+
+/**
+ * The tests were copied from the Scala 2.13 Standard Library. `scala.jdk.javaapi` stuff has been omitted and
+ * everything concerning `OptionalInt`, `OptionalDouble` and `OptionalLong` is only available on the jvm tests.
+ *
+ * See https://github.com/scala/scala/blob/2.13.x/test/junit/scala/jdk/OptionConvertersTest.scala.
+ */
+class OptionConvertersTest {
+  @Test
+  def scalaToEverything(): Unit = {
+    val o  = Option("fish")
+    val n  = None: Option[String]
+    val od = Option(2.7)
+    val nd = None: Option[Double]
+    val oi = Option(4)
+    val ni = None: Option[Int]
+    val ol = Option(-1L)
+    val nl = None: Option[Long]
+    assertEquals(o.toJava, Optional.of(o.get))
+    assertEquals(n.toJava, Optional.empty[String])
+    assertEquals(od.toJava.get: Double, Optional.of(od.get).get: Double, 0)
+    assertEquals(nd.toJava, Optional.empty[Double])
+    assertEquals(oi.toJava.get: Int, Optional.of(oi.get).get: Int)
+    assertEquals(ni.toJava, Optional.empty[Int])
+    assertEquals(ol.toJava.get: Long, Optional.of(ol.get).get: Long)
+    assertEquals(nl.toJava, Optional.empty[Long])
+  }
+
+  @Test
+  def javaGenericToEverything(): Unit = {
+    val o  = Optional.of("fish")
+    val n  = Optional.empty[String]
+    val od = Optional.of(2.7)
+    val nd = Optional.empty[Double]
+    val oi = Optional.of(4)
+    val ni = Optional.empty[Int]
+    val ol = Optional.of(-1L)
+    val nl = Optional.empty[Long]
+    assertEquals(o.toScala, Option(o.get))
+    assertEquals(n.toScala, Option.empty[String])
+    assertEquals(od.toScala, Option(od.get))
+    assertEquals(nd.toScala, Option.empty[Double])
+    assertEquals(oi.toScala, Option(oi.get))
+    assertEquals(ni.toScala, Option.empty[Int])
+    assertEquals(ol.toScala, Option(ol.get))
+    assertEquals(nl.toScala, Option.empty[Long])
+  }
+}

compat/src/test/scala-jvm/test/scala/jdk/OptionConvertersTest.scala renamed to compat/src/test/scala-jvm/test/scala/jdk/OptionConvertersJVMTest.scala

@@ -11,13 +11,14 @@ import scala.jdk.OptionConverters._
  *
  * See https://github.com/scala/scala/blob/2.13.x/test/junit/scala/jdk/OptionConvertersTest.scala.
  */
-class OptionConvertersTest {
+class OptionConvertersJVMTest {
   @Test
   def scalaToEverything(): Unit = {
     val o  = Option("fish")
     val n  = (None: Option[String])
     val od = Option(2.7)
     val nd = (None: Option[Double])
+
     val oi = Option(4)
     val ni = (None: Option[Int])
     val ol = Option(-1L)