Dialyzer Warning in Task.Supervisor

[maennchen]

Elixir and Erlang/OTP versions

Erlang/OTP 28 [erts-16.0.2] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1] [jit:ns]

Elixir 1.18.4 (compiled with Erlang/OTP 25)

Operating system

Ubuntu 24.04

Current behavior

defmodule Test do
  @spec run_task() :: Task.t()
  def run_task do
    Task.Supervisor.async(SupervisorName, fn ->
      # Your task implementation here
      :ok
    end)
  end
end

=>

lib/test.ex:2:contract_with_opaque
The @spec for Test.run_task/0 has an opaque
subtype %Task{
  :mfa => {atom(), atom(), byte()},
  :owner => pid(),
  :pid => nil | pid(),
  :ref => Task.ref()
} which is violated by the success typing.

Success typing:
() :: %Task{
  :mfa => {_, _, non_neg_integer()},
  :owner => pid(),
  :pid => atom() | pid() | port() | {atom(), atom()},
  :ref => reference()
}

Expected behavior

No Warning

[maennchen]

This is most likely connected to #14576 and erlang/otp#9936.

It only happens when using OTP 28, no issues on OTP 27.

Can be observed in the wild in quantum-elixir/quantum-core#641

[sabiwara]

This is most likely connected to #14576 and erlang/otp#9936.

It's probably related to the same change in OTP, but this one doesn't seem due to literal inlining.
I think the issue is that Task.Supervisor creates a Task.t() directly by passing a %Task{ref: ref}, violating the opacity... and instead of just reporting it there, it bubbles up in callers of Task.Supervisor?

https://github.com/elixir-lang/elixir/blob/v1.18.4/lib/elixir/lib/task/supervisor.ex#L603

We could probably fix it by calling a private Task.new or sth, but...
Given how opaque can be so hard to work with, I'm tempted to suggest we just remove the dialyzer opaqueness and just document it as something that should be considered opaque instead?
And perhaps we could then revisit it if we add opaque types in the new typesystem?

[maennchen]

@sabiwara Could it also be the different type in the pid field? nil | pid() and atom() | pid() | port() | {atom(), atom()} does not sound very compatible.

[josevalim]

I believe it is opaqueness. The success typing is inferred and can be a supertype indeed. I would probably remove the ref from opaque and say it can be any term().

[maennchen]

@josevalim Do you mean this?

diff --git a/lib/elixir/lib/task.ex b/lib/elixir/lib/task.ex
index ef7af6ebd..d758c2a27 100644
--- a/lib/elixir/lib/task.ex
+++ b/lib/elixir/lib/task.ex
@@ -295,7 +295,7 @@ def run(arg) do
   @typedoc """
   The task opaque reference.
   """
-  @opaque ref :: reference()
+  @type ref :: reference()
 
   @typedoc """
   Options given to `async_stream` functions.

or this?

diff --git a/lib/elixir/lib/task.ex b/lib/elixir/lib/task.ex
index ef7af6ebd..152005e7f 100644
--- a/lib/elixir/lib/task.ex
+++ b/lib/elixir/lib/task.ex
@@ -289,7 +289,7 @@ def run(arg) do
           mfa: mfa(),
           owner: pid(),
           pid: pid() | nil,
-          ref: ref()
+          ref: term()
         }
 
   @typedoc """

[josevalim]

I meant this:

-  @opaque ref :: reference()
+  @type ref :: term()

But it will break dialyzing in Elixir itself :'(

[sabiwara]

OK actually dialyzer was right here, I think this is a good way to address this: #14656