chore: Use scala.jdk.DurationConverters

Author: He-Pin

CONTRIBUTING.md

@@ -552,16 +552,16 @@ Scala has proven the most viable way to do it, as long as you keep the following
 
 #### Overview of Scala types and their Java counterparts
 
-| Scala | Java |
-|-------|------|
-| `scala.Option[T]` | `java.util.Optional<T>` (`OptionalDouble`, ...) |
-| `scala.collection.immutable.Seq[T]` | `java.util.List<T>` |
-| `scala.concurrent.Future[T]` | `java.util.concurrent.CompletionStage<T>` |
-| `scala.concurrent.Promise[T]` | `java.util.concurrent.CompletableFuture<T>` |
-| `scala.concurrent.duration.FiniteDuration` | `java.time.Duration` (use `org.apache.pekko.util.JavaDurationConverters`) |
-| `T => Unit` | `java.util.function.Consumer<T>` |
-| `() => R` (`scala.Function0[R]`) | `java.util.function.Supplier<R>` |
-| `T => R` (`scala.Function1[T, R]`) | `java.util.function.Function<T, R>` |
+| Scala | Java                                                           |
+|-------|----------------------------------------------------------------|
+| `scala.Option[T]` | `java.util.Optional<T>` (`OptionalDouble`, ...)                |
+| `scala.collection.immutable.Seq[T]` | `java.util.List<T>`                                            |
+| `scala.concurrent.Future[T]` | `java.util.concurrent.CompletionStage<T>`                      |
+| `scala.concurrent.Promise[T]` | `java.util.concurrent.CompletableFuture<T>`                    |
+| `scala.concurrent.duration.FiniteDuration` | `java.time.Duration` (use `scala.jdk.javaapi.DurationConverters`) |
+| `T => Unit` | `java.util.function.Consumer<T>`                               |
+| `() => R` (`scala.Function0[R]`) | `java.util.function.Supplier<R>`                               |
+| `T => R` (`scala.Function1[T, R]`) | `java.util.function.Function<T, R>`                            |
 
 ### Contributing new Pekko Streams operators
 

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/Effect.scala

@@ -19,7 +19,7 @@ import org.apache.pekko
 import pekko.actor.typed.{ ActorRef, Behavior, Props }
 import pekko.annotation.{ DoNotInherit, InternalApi }
 import pekko.util.FunctionConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.unused
 
 /**
@@ -198,7 +198,7 @@ object Effect {
     /**
      * Java API
      */
-    def duration(): java.time.Duration = d.asJava
+    def duration(): java.time.Duration = d.toJava
   }
 
   case object ReceiveTimeoutCancelled extends ReceiveTimeoutCancelled
@@ -210,7 +210,7 @@ object Effect {
    * FIXME what about events scheduled through the scheduler?
    */
   final case class Scheduled[U](delay: FiniteDuration, target: ActorRef[U], message: U) extends Effect {
-    def duration(): java.time.Duration = delay.asJava
+    def duration(): java.time.Duration = delay.toJava
   }
 
   final case class TimerScheduled[U](
@@ -220,11 +220,11 @@ object Effect {
       mode: TimerScheduled.TimerMode,
       overriding: Boolean)(val send: () => Unit)
       extends Effect {
-    def duration(): java.time.Duration = delay.asJava
+    def duration(): java.time.Duration = delay.toJava
   }
 
   object TimerScheduled {
-    import pekko.util.JavaDurationConverters._
+    import scala.jdk.DurationConverters._
 
     sealed trait TimerMode
     case object FixedRateMode extends TimerMode
@@ -235,9 +235,9 @@ object Effect {
 
     /*Java API*/
     def fixedRateMode = FixedRateMode
-    def fixedRateMode(initialDelay: java.time.Duration) = FixedRateModeWithInitialDelay(initialDelay.asScala)
+    def fixedRateMode(initialDelay: java.time.Duration) = FixedRateModeWithInitialDelay(initialDelay.toScala)
     def fixedDelayMode = FixedDelayMode
-    def fixedDelayMode(initialDelay: java.time.Duration) = FixedDelayModeWithInitialDelay(initialDelay.asScala)
+    def fixedDelayMode(initialDelay: java.time.Duration) = FixedDelayModeWithInitialDelay(initialDelay.toScala)
     def singleMode = SingleMode
   }
 

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala

@@ -21,7 +21,7 @@ import org.apache.pekko
 import pekko.actor.typed.ActorSystem
 import pekko.actor.typed.Extension
 import pekko.actor.typed.ExtensionId
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 object TestKitSettings {
@@ -97,5 +97,5 @@ final class TestKitSettings(val config: Config) {
    * Java API: Scale the `duration` with the configured `TestTimeFactor`
    */
   def dilated(duration: java.time.Duration): java.time.Duration =
-    dilated(duration.asScala).asJava
+    dilated(duration.toScala).toJava
 }

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestProbeImpl.scala

@@ -43,7 +43,7 @@ import pekko.actor.typed.scaladsl.Behaviors
 import pekko.annotation.InternalApi
 import pekko.japi.function.Creator
 import pekko.util.BoxedType
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.PrettyDuration._
 import pekko.util.ccompat.JavaConverters._
 
@@ -102,14 +102,14 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
 
   override def remainingOrDefault: FiniteDuration = remainingOr(settings.SingleExpectDefaultTimeout)
 
-  override def getRemainingOrDefault: JDuration = remainingOrDefault.asJava
+  override def getRemainingOrDefault: JDuration = remainingOrDefault.toJava
 
   override def remaining: FiniteDuration = end match {
     case f: FiniteDuration => f - now
     case _                 => assertFail("`remaining` may not be called outside of `within`")
   }
 
-  override def getRemaining: JDuration = remaining.asJava
+  override def getRemaining: JDuration = remaining.toJava
 
   override def remainingOr(duration: FiniteDuration): FiniteDuration = end match {
     case x if x eq Duration.Undefined => duration
@@ -119,7 +119,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
   }
 
   override def getRemainingOr(duration: JDuration): JDuration =
-    remainingOr(duration.asScala).asJava
+    remainingOr(duration.toScala).toJava
 
   override def within[T](min: FiniteDuration, max: FiniteDuration)(f: => T): T =
     within_internal(min, max.dilated, f)
@@ -128,10 +128,10 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     within_internal(Duration.Zero, max.dilated, f)
 
   override def within[T](min: JDuration, max: JDuration)(f: Supplier[T]): T =
-    within_internal(min.asScala, max.asScala.dilated, f.get())
+    within_internal(min.toScala, max.toScala.dilated, f.get())
 
   def within[T](max: JDuration)(f: Supplier[T]): T =
-    within_internal(Duration.Zero, max.asScala.dilated, f.get())
+    within_internal(Duration.Zero, max.toScala.dilated, f.get())
 
   private def within_internal[T](min: FiniteDuration, max: FiniteDuration, f: => T): T = {
     val start = now
@@ -162,13 +162,13 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
   override def expectMessage[T <: M](max: FiniteDuration, obj: T): T = expectMessage_internal(max.dilated, obj)
 
   override def expectMessage[T <: M](max: JDuration, obj: T): T =
-    expectMessage(max.asScala, obj)
+    expectMessage(max.toScala, obj)
 
   override def expectMessage[T <: M](max: FiniteDuration, hint: String, obj: T): T =
     expectMessage_internal(max.dilated, obj, Some(hint))
 
   override def expectMessage[T <: M](max: JDuration, hint: String, obj: T): T =
-    expectMessage(max.asScala, hint, obj)
+    expectMessage(max.toScala, hint, obj)
 
   private def expectMessage_internal[T <: M](max: FiniteDuration, obj: T, hint: Option[String] = None): T = {
     if (obj.isInstanceOf[Signal])
@@ -185,7 +185,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
 
   override def receiveMessage(): M = receiveMessage_internal(remainingOrDefault)
 
-  override def receiveMessage(max: JDuration): M = receiveMessage(max.asScala)
+  override def receiveMessage(max: JDuration): M = receiveMessage(max.toScala)
 
   override def receiveMessage(max: FiniteDuration): M = receiveMessage_internal(max.dilated)
 
@@ -212,7 +212,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     expectNoMessage_internal(max)
 
   override def expectNoMessage(max: JDuration): Unit =
-    expectNoMessage(max.asScala)
+    expectNoMessage(max.toScala)
 
   override def expectNoMessage(): Unit =
     expectNoMessage_internal(settings.ExpectNoMessageDefaultTimeout)
@@ -232,10 +232,10 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     expectMessageClass_internal(max.dilated, t.runtimeClass.asInstanceOf[Class[T]])
 
   override def expectMessageClass[T <: M](clazz: Class[T]): T =
-    expectMessageClass_internal(getRemainingOrDefault.asScala, clazz)
+    expectMessageClass_internal(getRemainingOrDefault.toScala, clazz)
 
   override def expectMessageClass[T <: M](clazz: Class[T], max: JDuration): T =
-    expectMessageClass_internal(max.asScala.dilated, clazz)
+    expectMessageClass_internal(max.toScala.dilated, clazz)
 
   private def expectMessageClass_internal[C](max: FiniteDuration, c: Class[C]): C = {
     if (classOf[Signal].isAssignableFrom(c)) {
@@ -258,10 +258,10 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     receiveMessages_internal(n, max.dilated)
 
   override def receiveSeveralMessages(n: Int): JList[M] =
-    receiveMessages_internal(n, getRemainingOrDefault.asScala).asJava
+    receiveMessages_internal(n, getRemainingOrDefault.toScala).asJava
 
   override def receiveSeveralMessages(n: Int, max: JDuration): JList[M] =
-    receiveMessages_internal(n, max.asScala.dilated).asJava
+    receiveMessages_internal(n, max.toScala.dilated).asJava
 
   private def receiveMessages_internal(n: Int, max: FiniteDuration): immutable.Seq[M] = {
     val stop = max + now
@@ -295,7 +295,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
       max: JDuration,
       hint: String,
       fisher: java.util.function.Function[M, FishingOutcome]): JList[M] =
-    fishForMessage_internal(max.asScala.dilated, hint, fisher.apply).asJava
+    fishForMessage_internal(max.toScala.dilated, hint, fisher.apply).asJava
 
   private def fishForMessage_internal(max: FiniteDuration, hint: String, fisher: M => FishingOutcome): List[M] = {
     @tailrec def loop(timeout: FiniteDuration, seen: List[M]): List[M] = {
@@ -338,7 +338,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     expectTerminated_internal(actorRef, remainingOrDefault)
 
   override def expectTerminated[U](actorRef: ActorRef[U], max: JDuration): Unit =
-    expectTerminated_internal(actorRef, max.asScala.dilated)
+    expectTerminated_internal(actorRef, max.toScala.dilated)
 
   private def expectTerminated_internal[U](actorRef: ActorRef[U], max: FiniteDuration): Unit = {
     testActor.asInstanceOf[ActorRef[AnyRef]] ! WatchActor(actorRef)
@@ -364,7 +364,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     awaitAssert_internal(a, remainingOrDefault, 100.millis)
 
   override def awaitAssert[A](max: JDuration, interval: JDuration, creator: Creator[A]): A =
-    awaitAssert_internal(creator.create(), max.asScala.dilated, interval.asScala)
+    awaitAssert_internal(creator.create(), max.toScala.dilated, interval.toScala)
 
   def awaitAssert[A](max: JDuration, creator: Creator[A]): A =
     awaitAssert(max, JDuration.ofMillis(100), creator)

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ActorTestKit.scala

@@ -29,7 +29,7 @@ import pekko.actor.typed.ActorSystem
 import pekko.actor.typed.Behavior
 import pekko.actor.typed.Props
 import pekko.actor.typed.Scheduler
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 object ActorTestKit {
@@ -123,7 +123,7 @@ object ActorTestKit {
    *                             no exception is thrown.
    */
   def shutdown(system: ActorSystem[_], duration: Duration, throwIfShutdownTimesOut: Boolean): Unit = {
-    TestKitUtils.shutdown(system, duration.asScala, throwIfShutdownTimesOut)
+    TestKitUtils.shutdown(system, duration.toScala, throwIfShutdownTimesOut)
   }
 
   /**
@@ -143,7 +143,7 @@ object ActorTestKit {
    */
   def shutdown(system: ActorSystem[_]): Unit = {
     val settings = TestKitSettings.create(system)
-    shutdown(system, settings.DefaultActorSystemShutdownTimeout.asJava, settings.ThrowOnShutdownTimeout)
+    shutdown(system, settings.DefaultActorSystemShutdownTimeout.toJava, settings.ThrowOnShutdownTimeout)
   }
 
   /**
@@ -222,7 +222,7 @@ final class ActorTestKit private[pekko] (delegate: pekko.actor.testkit.typed.sca
    * It can only be used for actors that were spawned by this `ActorTestKit`.
    * Other actors will not be stopped by this method.
    */
-  def stop[T](ref: ActorRef[T], max: Duration): Unit = delegate.stop(ref, max.asScala)
+  def stop[T](ref: ActorRef[T], max: Duration): Unit = delegate.stop(ref, max.toScala)
 
   /**
    * Shortcut for creating a new test probe for the testkit actor system

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/Effects.scala

@@ -17,7 +17,7 @@ import java.time.Duration
 
 import org.apache.pekko
 import pekko.actor.typed.{ ActorRef, Behavior, Props }
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * Factories for behavior effects for [[BehaviorTestKit]], each effect has a suitable equals and can be used to compare
@@ -94,14 +94,14 @@ object Effects {
   /**
    * The behavior set a new receive timeout, with `message` as timeout notification
    */
-  def receiveTimeoutSet[T](d: Duration, message: T): ReceiveTimeoutSet[T] = ReceiveTimeoutSet(d.asScala, message)
+  def receiveTimeoutSet[T](d: Duration, message: T): ReceiveTimeoutSet[T] = ReceiveTimeoutSet(d.toScala, message)
 
   /**
    * The behavior used `context.schedule` to schedule `message` to be sent to `target` after `delay`
    * FIXME what about events scheduled through the scheduler?
    */
   def scheduled[U](delay: Duration, target: ActorRef[U], message: U): Scheduled[U] =
-    Scheduled(delay.asScala, target, message)
+    Scheduled(delay.toScala, target, message)
 
   def timerScheduled[U](
       key: Any,
@@ -110,7 +110,7 @@ object Effects {
       mode: TimerScheduled.TimerMode,
       overriding: Boolean,
       send: pekko.japi.function.Effect): TimerScheduled[U] =
-    TimerScheduled(key, msg, delay.asScala, mode, overriding)(send.apply _)
+    TimerScheduled(key, msg, delay.toScala, mode, overriding)(send.apply _)
 
   /**
    * Used to represent an empty list of effects - in other words, the behavior didn't do anything observable

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ManualTime.scala

@@ -22,7 +22,7 @@ import com.typesafe.config.Config
 import org.apache.pekko
 import pekko.actor.typed.ActorSystem
 import pekko.actor.typed.internal.adapter.SchedulerAdapter
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * Manual time allows you to do async tests while controlling the scheduler of the system.
@@ -70,11 +70,11 @@ final class ManualTime(delegate: pekko.testkit.ExplicitlyTriggeredScheduler) {
    * If you want the amount of time passed to be dilated, apply the dilation before passing the delay to
    * this method.
    */
-  def timePasses(amount: Duration): Unit = delegate.timePasses(amount.asScala)
+  def timePasses(amount: Duration): Unit = delegate.timePasses(amount.toScala)
 
   @varargs
   def expectNoMessageFor(duration: Duration, on: TestProbe[_]*): Unit = {
-    delegate.timePasses(duration.asScala)
+    delegate.timePasses(duration.toScala)
     on.foreach(_.expectNoMessage(Duration.ZERO))
   }
 

actor-tests/src/test/java/org/apache/pekko/pattern/CircuitBreakerTest.java

@@ -24,11 +24,11 @@
 import org.apache.pekko.testkit.PekkoJUnitActorSystemResource;
 import org.apache.pekko.testkit.PekkoSpec;
 import org.apache.pekko.util.FutureConverters;
-import org.apache.pekko.util.JavaDurationConverters;
 import org.junit.ClassRule;
 import org.junit.Test;
 import org.scalatestplus.junit.JUnitSuite;
 import scala.concurrent.Await;
+import scala.jdk.javaapi.DurationConverters;
 
 public class CircuitBreakerTest extends JUnitSuite {
 
@@ -51,8 +51,7 @@ public void useCircuitBreakerWithCompletableFuture() throws Exception {
     final CompletionStage<String> res = breaker.callWithCircuitBreakerCS(() -> f);
     assertEquals(
         "hello",
-        Await.result(
-            FutureConverters.asScala(res), JavaDurationConverters.asFiniteDuration(fiveSeconds)));
+        Await.result(FutureConverters.asScala(res), DurationConverters.toScala(fiveSeconds)));
   }
 
   @Test
@@ -71,8 +70,7 @@ public void useCircuitBreakerWithCompletableFutureAndCustomDefineFailure() throw
     final CompletionStage<String> res = breaker.callWithCircuitBreakerCS(() -> f, fn);
     assertEquals(
         "hello",
-        Await.result(
-            FutureConverters.asScala(res), JavaDurationConverters.asFiniteDuration(fiveSeconds)));
+        Await.result(FutureConverters.asScala(res), DurationConverters.toScala(fiveSeconds)));
     assertEquals(1, breaker.currentFailureCount());
   }
 }

actor-tests/src/test/java/org/apache/pekko/util/JavaConverterScala3InlineTest.java

@@ -17,15 +17,14 @@
 
 package org.apache.pekko.util;
 
-import java.time.Duration;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import scala.Option;
 import scala.concurrent.Future;
 
 /**
  * These tests are here to ensure that methods from {@link org.apache.pekko.util.FutureConverters},
- * {@link org.apache.pekko.util.JavaDurationConverters} and {@link
+ * {@link org.apache.scala.jdk.DurationConverters} and {@link
  * org.apache.pekko.util.OptionConverters} for use within Java can be compiled from with Java
  * sources. This is because methods marked with the Scala 3 inline keyword cannot be called from
  * within Java (see https://github.com/lampepfl/dotty/issues/19346)
@@ -40,7 +39,5 @@ public void compileTest() {
 
     FutureConverters.asJava(Future.successful(""));
     FutureConverters.asScala(CompletableFuture.completedFuture(""));
-
-    JavaDurationConverters.asFiniteDuration(Duration.ofMillis(0));
   }
 }