Do not use JavaConverters anymore.

Because they are too hard to cross-compile without warnings across
Scala 2.12- and 2.13+.

Author: sjrd

src/main/scala/java/time/Duration.scala

@@ -1,9 +1,9 @@
 package java.time
 
-import scala.collection.JavaConverters._
-
 import java.time.temporal._
 
+import java.{util => ju}
+
 final class Duration private (seconds: Long, nanos: Int)
     extends TemporalAmount with Comparable[Duration]
     with java.io.Serializable {
@@ -29,7 +29,7 @@ final class Duration private (seconds: Long, nanos: Int)
   }
 
   def getUnits(): java.util.List[TemporalUnit] =
-    Seq[TemporalUnit](SECONDS, NANOS).asJava
+    ju.Collections.unmodifiableList(ju.Arrays.asList(SECONDS, NANOS))
 
   def isZero(): Boolean = seconds == 0 && nanos == 0
 
@@ -274,9 +274,13 @@ object Duration {
   }
 
   def from(amount: TemporalAmount): Duration = {
-    amount.getUnits.asScala.foldLeft(ZERO) { (d, u) =>
-      d.plus(amount.get(u), u)
+    var result = ZERO
+    val iter = amount.getUnits().iterator()
+    while (iter.hasNext()) {
+      val unit = iter.next()
+      result = result.plus(amount.get(unit), unit)
     }
+    result
   }
 
   // Not implemented

src/main/scala/java/time/Period.scala

@@ -1,9 +1,8 @@
 package java.time
 
-import scala.collection.JavaConverters._
-
 import java.time.chrono.{IsoChronology, ChronoPeriod}
 import java.time.temporal._
+
 import java.{util => ju}
 
 final class Period private (years: Int, months: Int, days: Int)
@@ -20,7 +19,7 @@ final class Period private (years: Int, months: Int, days: Int)
   }
 
   def getUnits(): ju.List[TemporalUnit] =
-    Seq[TemporalUnit](YEARS, MONTHS, DAYS).asJava
+    ju.Collections.unmodifiableList(ju.Arrays.asList(YEARS, MONTHS, DAYS))
 
   def getChronology(): IsoChronology = IsoChronology.INSTANCE
 
@@ -170,21 +169,25 @@ object Period {
     case amount: Period => amount
 
     case _ =>
-      amount.getUnits().asScala.foldLeft(ZERO) { (p, unit) =>
+      var result = ZERO
+      val iter = amount.getUnits().iterator()
+      while (iter.hasNext()) {
+        val unit = iter.next()
         unit match {
           case ChronoUnit.YEARS =>
-            p.withYears(Math.toIntExact(amount.get(unit)))
+            result = result.withYears(Math.toIntExact(amount.get(unit)))
 
           case ChronoUnit.MONTHS =>
-            p.withMonths(Math.toIntExact(amount.get(unit)))
+            result = result.withMonths(Math.toIntExact(amount.get(unit)))
 
           case ChronoUnit.DAYS =>
-            p.withDays(Math.toIntExact(amount.get(unit)))
+            result = result.withDays(Math.toIntExact(amount.get(unit)))
 
           case _ =>
             throw new DateTimeException(s"Unit not allowed: $unit")
         }
       }
+      result
   }
 
   def between(start: LocalDate, end: LocalDate): Period = start.until(end)

src/main/scala/java/time/chrono/ChronoPeriod.scala

@@ -1,15 +1,14 @@
 package java.time.chrono
 
-import scala.collection.JavaConverters._
-
 import java.time.temporal.{Temporal, TemporalAmount}
+import java.time.temporal.TemporalUnit
 
 trait ChronoPeriod extends TemporalAmount {
   def getChronology(): Chronology
 
-  def isZero(): Boolean = getUnits.asScala.forall(get(_) == 0)
+  def isZero(): Boolean = forallUnits(get(_) == 0)
 
-  def isNegative(): Boolean = getUnits.asScala.exists(get(_) < 0)
+  def isNegative(): Boolean = !forallUnits(get(_) >= 0)
 
   def plus(amount: TemporalAmount): ChronoPeriod
 
@@ -24,6 +23,17 @@ trait ChronoPeriod extends TemporalAmount {
   def addTo(temporal: Temporal): Temporal
 
   def subtractFrom(temporal: Temporal): Temporal
+
+  private def forallUnits(f: TemporalUnit => Boolean): Boolean = {
+    // scalastyle:off return
+    val iter = getUnits().iterator()
+    while (iter.hasNext()) {
+      if (!f(iter.next()))
+        return false
+    }
+    true
+    // scalastyle:on return
+  }
 }
 
 object ChronoPeriod {

src/main/scala/java/time/chrono/Chronology.scala

@@ -1,6 +1,5 @@
 package java.time.chrono
 
-import scala.collection.JavaConverters._
 import scala.scalajs.js
 
 import java.time.{Period, DateTimeException}
@@ -70,11 +69,17 @@ object Chronology {
   // def ofLocale(locale: ju.Locale): Chronology
 
   def of(id: String): Chronology = {
-    getAvailableChronologies().asScala.find(_.getId == id).getOrElse {
-      throw new DateTimeException(s"Unknown chronology: $id")
+    // scalastyle:off return
+    val iter = getAvailableChronologies().iterator()
+    while (iter.hasNext()) {
+      val chronology = iter.next()
+      if (chronology.getId() == id)
+        return chronology
     }
+    throw new DateTimeException(s"Unknown chronology: $id")
+    // scalastyle:on return
   }
 
   def getAvailableChronologies(): ju.Set[Chronology] =
-    Set[Chronology](IsoChronology.INSTANCE).asJava
+    ju.Collections.singleton(IsoChronology.INSTANCE)
 }

src/main/scala/java/time/chrono/IsoChronology.scala

@@ -1,7 +1,5 @@
 package java.time.chrono
 
-import scala.collection.JavaConverters._
-
 import java.time.{Period, LocalDate}
 import java.time.temporal.{ValueRange, ChronoField, TemporalAccessor}
 import java.{util => ju}
@@ -53,7 +51,8 @@ final class IsoChronology private () extends AbstractChronology with Serializabl
 
   def eraOf(eraValue: Int): IsoEra = IsoEra.of(eraValue)
 
-  def eras(): ju.List[Era] = Seq[Era](IsoEra.BCE, IsoEra.CE).asJava
+  def eras(): ju.List[Era] =
+    ju.Collections.unmodifiableList(ju.Arrays.asList(IsoEra.BCE, IsoEra.CE))
 
   // Not implemented
   // def resolveDate(fieldValues: ju.Map[TemporalField, Long],

testSuite/shared/src/test/scala/org/scalajs/testsuite/javalib/time/TemporalAmountTest.scala

@@ -2,8 +2,6 @@ package org.scalajs.testsuite.javalib.time
 
 import java.time.temporal.{UnsupportedTemporalTypeException, ChronoUnit, TemporalAmount}
 
-import scala.collection.JavaConverters._
-
 import org.junit.Test
 import org.junit.Assert._
 import org.scalajs.testsuite.utils.AssertThrows._
@@ -25,6 +23,6 @@ abstract class TemporalAmountTest {
 
   @Test def test_getUnits(): Unit = {
     for (amount <- samples)
-      assertEquals(units.toIterable, amount.getUnits.asScala)
+      assertArrayEquals(units.toArray[AnyRef], amount.getUnits.toArray())
   }
 }