Unexpected Error when resolving the right overloaded method

[He-Pin]

Compiler version

3.3.6

Minimized code

https://github.com/apache/pekko/blob/main/actor/src/main/scala/org/apache/pekko/pattern/FutureTimeoutSupport.scala#L145

If I remove the (), it then compiles error.

//> using scala "3.3.6"

import java.util.concurrent.{ CompletionStage, TimeoutException }
import scala.concurrent.duration.FiniteDuration

def scheduleOnce(delay: java.time.Duration, runnable: Runnable): Unit = ???
def scheduleOnce(delay: FiniteDuration, runnable: Runnable): Unit = ???
def scheduleOnce(delay: FiniteDuration)(f: => Unit): Unit = ???

def timeoutCompletionStage[T](duration: java.time.Duration)(value: => CompletionStage[T]): Unit = {
  val stage = value
  val p = new java.util.concurrent.CompletableFuture[T]
  scheduleOnce(
    duration,
    () => {
      p.completeExceptionally(new TimeoutException(s"Timeout of $duration expired"))
      stage.toCompletableFuture.cancel(true)
    }
  )
}

Output

[error] -- [E134] Type Error: /Users/hepin/IdeaProjects/pekko/actor/src/main/scala/org/apache/pekko/pattern/FutureTimeoutSupport.scala:141:26 
[error] 141 |      val timeout = using.scheduleOnce(duration,
[error]     |                    ^^^^^^^^^^^^^^^^^^
[error]     |None of the overloaded alternatives of method scheduleOnce in trait Scheduler with types
[error]     | (delay: java.time.Duration, runnable: Runnable)
[error]     |  (implicit executor: scala.concurrent.ExecutionContext):
[error]     |    org.apache.pekko.actor.Cancellable
[error]     | (delay: scala.concurrent.duration.FiniteDuration, runnable: Runnable)
[error]     |  (implicit executor: scala.concurrent.ExecutionContext):
[error]     |    org.apache.pekko.actor.Cancellable
[error]     | (delay: scala.concurrent.duration.FiniteDuration)
[error]     |  (f: => Unit)
[error]     |    (implicit executor: scala.concurrent.ExecutionContext):
[error]     |      org.apache.pekko.actor.Cancellable
[error]     | (delay: java.time.Duration, receiver: org.apache.pekko.actor.ActorRef,
[error]     |  message: Any, executor: scala.concurrent.ExecutionContext, sender:
[error]     |  org.apache.pekko.actor.ActorRef): org.apache.pekko.actor.Cancellable
[error]     | (delay: scala.concurrent.duration.FiniteDuration,
[error]     |  receiver: org.apache.pekko.actor.ActorRef, message: Any)
[error]     |  (implicit executor: scala.concurrent.ExecutionContext, sender:
[error]     |    org.apache.pekko.actor.ActorRef): org.apache.pekko.actor.Cancellable
[error]     |match arguments ((duration² : java.time.Duration), () => Boolean)
[error]     |
[error]     |where:    duration  is a package in package scala.concurrent
[error]     |          duration² is a parameter in method timeoutCompletionStage
[error] one error found
[error] (Compile / compileIncremental) Compilation failed

Expectation

It should compile, or just gives expect () => Unit of runnable ,but got () => Boolean,

[bracevac]

This needs to be further minimized.

[He-Pin]

//> using scala "3.3.6"

import java.util.concurrent.{ CompletionStage, TimeoutException }
import scala.concurrent.duration.FiniteDuration

def scheduleOnce(delay: java.time.Duration, runnable: Runnable): Unit = ???
def scheduleOnce(delay: FiniteDuration, runnable: Runnable): Unit = ???
def scheduleOnce(delay: FiniteDuration)(f: => Unit): Unit = ???

def timeoutCompletionStage[T](duration: java.time.Duration)(value: => CompletionStage[T]): Unit = {
  val stage = value
  val p = new java.util.concurrent.CompletableFuture[T]
  scheduleOnce(
    duration,
    () => {
      p.completeExceptionally(new TimeoutException(s"Timeout of $duration expired"))
      stage.toCompletableFuture.cancel(true)
    }
  )
}

Now another error:(

/Users/hepin/IdeaProjects/pekko/actor/src/main/scala/org/apache/pekko/pattern/Resolve.sc:14:5
type mismatch;
found   : java.time.Duration
required: scala.concurrent.duration.FiniteDuration
duration,

and

[error] ./Res.sc:13:3
[error] None of the overloaded alternatives of method scheduleOnce in class Res$_ with types
[error]  (delay: scala.concurrent.duration.FiniteDuration)(f: => Unit): Unit
[error]  (delay: scala.concurrent.duration.FiniteDuration, runnable: Runnable): Unit
[error]  (delay: java.time.Duration, runnable: Runnable): Unit
[error] match arguments ((duration² : java.time.Duration), () => Boolean)
[error] 
[error] where:    duration  is a package in package scala.concurrent
[error]           duration² is a parameter in method timeoutCompletionStage
[error]   scheduleOnce(
[error]   ^^^^^^^^^^^^
Error compiling project (Scala 3.3.6, JVM (11))

You can see, the first argument is duration: java.time.Duration, so I would expects def scheduleOnce(delay: java.time.Duration, runnable: Runnable): Unit = to be selected.

[He-Pin]

And I also expect the () is not needed, the compiler can ignore the return boolean value of CompletableFuture.cancel(true) and insert an () just as Java.

[He-Pin]

//> using scala "3.3.6"

import java.util.concurrent.{ CompletionStage, TimeoutException }
import scala.concurrent.duration.FiniteDuration

def scheduleOnce(delay: java.time.Duration, runnable: Runnable): Unit = ???
def scheduleOnce(delay: FiniteDuration, runnable: Runnable): Unit = ???
def scheduleOnce(delay: FiniteDuration)(f: => Unit): Unit = ???

def timeoutCompletionStage[T](duration: java.time.Duration)(value: => CompletionStage[T]): Unit = {
  val stage = value
  val p = new java.util.concurrent.CompletableFuture[T]
  scheduleOnce(
    duration,
    () => {
      p.completeExceptionally(new TimeoutException(s"Timeout of $duration expired"))
      stage.toCompletableFuture.cancel(true)
	      ()
    }
  )
}

And not sure why this will give another error:

hepin@192 ~ % scala-cli Res.sc
Compiling project (Scala 3.3.6, JVM (11))
[error] ./Res.sc:18:8
[error] Incompatible combinations of tabs and spaces in indentation prefixes.
[error] Previous indent : 6 spaces
[error] Latest indent   : 1 tab, 6 spaces
[error] 	      ()
[error]        ^

I am using the {}, so I would expect no such error even I mixed the tab and spaces

[He-Pin]

@bracevac Sorry , I have minimized it.

[som-snytt]

@He-Pin I think even if you use braces, it uses indentation checks.

https://www.scala-lang.org/files/archive/api/current/docs/other-new-features/indentation.html#indentation-rules

[noti0na1]

Minimized:

def f(): Boolean = false
def g(x: String, y: () => Unit): Unit = ???
def g(x: Int, y: () => Unit): Unit = ???

def test = g("", () => f())

% scala compile -S 3.nightly i23799.scala 
Compiling project (Scala 3.8.0-RC1-bin-20250814-0cf7a18-NIGHTLY, JVM (21))
[error] ./i23799.scala:5:12
[error] None of the overloaded alternatives of method g with types
[error]  (x: Int, y: () => Unit): Unit
[error]  (x: String, y: () => Unit): Unit
[error] match arguments (("" : String), () => Boolean)
[error] def test = g("", () => f())
[error]            ^
Error compiling project (Scala 3.8.0-RC1-bin-20250814-0cf7a18-NIGHTLY, JVM (21))
Compilation failed

The compiler can automatically get rid of the value in the last statement if the result type is known to be Unit. The interacting with overloading cases this bug. The error can be bypassed now if we return () explicitly:

def test = g("", () => { f(); () })