Surprising Dialyzer Warnings for MapSets

[Fritzelblitz]

Elixir and Erlang/OTP versions

Elixir 1.18.4
OTP-28.0
(both installed with Mise)

Operating system

Ubuntu 25.04

Current behavior

When using dialyzer to check the following Elixir Code

defmodule Foo do
  @spec foo() :: Ecto.Multi.t()
  def foo() do
    Ecto.Multi.new()
  end
end

we get the following Warning:

lib/foo.ex:2:contract_with_opaque
The @spec for Foo.foo/0 has an opaque
subtype %Ecto.Multi{
  :names => %MapSet{:map => MapSet.internal(_)},
  :operations => [
    {_,
     {:inspect, Keyword.t()}
     | {:merge,
        (map() -> %Ecto.Multi{:names => map(), :operations => [{_, _}], _ => _})
        | {atom(), atom(), [any()]}}
     | {:put, _}
     | {:run, (atom(), map() -> {:error, _} | {:ok, _})}
     | {:changeset,
        %Ecto.Changeset{
          :action => atom(),
          :changes => %{atom() => _},
          :constraints => [
            %{
              :constraint =>
                binary()
                | %Regex{
                    :opts => binary() | [any()],
                    :re_pattern => _,
                    :re_version => _,
                    :source => binary()
                  },
              :error_message => binary(),
              :error_type => atom(),
              :field => atom(),
              :match => :exact | :prefix | :suffix,
              :type => :check | :exclusion | :foreign_key | :unique
            }
          ],
          :data => nil | map(),
          :empty_values => _,
          :errors => Keyword.t({binary(), Keyword.t()}),
          :filters => %{atom() => _},
          :params => nil | %{binary() => _},
          :prepare => [(_ -> any())],
          :repo => atom(),
          :repo_opts => Keyword.t(),
          :required => [atom()],
          :types => %{
            atom() =>
              atom()
              | {:array | :assoc | :embed | :in | :map | :parameterized | :supertype | :try,
                 _}
          },
          :valid? => boolean(),
          :validations => Keyword.t()
        }, Keyword.t()}
     | {:delete_all,
        %Ecto.Query{
          :aliases => _,
          :assocs => _,
          :combinations => _,
          :distinct => _,
          :from => _,
          :group_bys => _,
          :havings => _,
          :joins => _,
          :limit => _,
          :lock => _,
          :offset => _,
          :order_bys => _,
          :prefix => _,
          :preloads => _,
          :select => _,
          :sources => _,
          :updates => _,
          :wheres => _,
          :windows => _,
          :with_ctes => _
        }, Keyword.t()}
     | {:update_all,
        %Ecto.Query{
          :aliases => _,
          :assocs => _,
          :combinations => _,
          :distinct => _,
          :from => _,
          :group_bys => _,
          :havings => _,
          :joins => _,
          :limit => _,
          :lock => _,
          :offset => _,
          :order_bys => _,
          :prefix => _,
          :preloads => _,
          :select => _,
          :sources => _,
          :updates => _,
          :wheres => _,
          :windows => _,
          :with_ctes => _
        }, Keyword.t()}
     | {:insert_all, atom() | binary() | {binary(), atom()}, [Keyword.t() | map()],
        Keyword.t()}}
  ]
} which is violated by the success typing.

Success typing:
() :: %Ecto.Multi{:names => %MapSet{:map => %{}}, :operations => []}

I have another code snippet to reproduce which I suspect is related to the same issue.

defmodule MapsetDialyzer do
  @spec bar(MapSet.t()) :: term()
  def bar(set) do
    set
  end

  def foo() do
    bar(MapSet.new([1,2,3]))
  end
end

Dialyzer gives this warning:

The call 'Elixir.MapsetDialyzer':bar
         (#{'__struct__' => 'Elixir.MapSet',
            'map' => #{1 => [], 2 => [], 3 => []}}) does not have a term of type 
          #{'__struct__' := 'Elixir.MapSet',
            'map' := 'Elixir.MapSet':internal(_)} (with opaque subterms) as 1st argument

I suspect the error comes from how Elixir defines its MapSet Type. (

elixir/lib/elixir/lib/map_set.ex

Lines 53 to 57 in 7b20c28

	@type value :: term
	@opaque internal(value) :: :sets.set(value)
	@type t(value) :: %__MODULE__{map: internal(value)}
	@type t :: t(term)

)

Expected behavior

Dialyzer not returning a warning.

[Fritzelblitz]

I already raised this issue in the erlang/otp github, but they told me to report it here.
erlang/otp#9936

[josevalim]

Thank you! This only happens on 28? Can you provide a git repo that reproduces it?

[Fritzelblitz]

Yes it's only on 28.
I only have this small reproducer https://github.com/Fritzelblitz/MapSetDialyzer
mix dialyzer should produce

lib/foo.ex:2:contract_with_opaque
The @spec for Foo.foo/0 has an opaque
subtype %Ecto.Multi{
  :names => %MapSet{:map => MapSet.internal(_)},
  :operations => [
    {_,
     {:inspect, Keyword.t()}
     | {:merge,
        (map() -> %Ecto.Multi{:names => map(), :operations => [{_, _}], _ => _})
        | {atom(), atom(), [any()]}}
     | {:put, _}
     | {:run, (atom(), map() -> {:error, _} | {:ok, _})}
     | {:changeset,
        %Ecto.Changeset{
          :action => atom(),
          :changes => %{atom() => _},
          :constraints => [
            %{
              :constraint =>
                binary()
                | %Regex{
                    :opts => binary() | [any()],
                    :re_pattern => _,
                    :re_version => _,
                    :source => binary()
                  },
              :error_message => binary(),
              :error_type => atom(),
              :field => atom(),
              :match => :exact | :prefix | :suffix,
              :type => :check | :exclusion | :foreign_key | :unique
            }
          ],
          :data => nil | map(),
          :empty_values => _,
          :errors => Keyword.t({binary(), Keyword.t()}),
          :filters => %{atom() => _},
          :params => nil | %{binary() => _},
          :prepare => [(_ -> any())],
          :repo => atom(),
          :repo_opts => Keyword.t(),
          :required => [atom()],
          :types => %{
            atom() =>
              atom()
              | {:array | :assoc | :embed | :in | :map | :parameterized | :supertype | :try,
                 _}
          },
          :valid? => boolean(),
          :validations => Keyword.t()
        }, Keyword.t()}
     | {:delete_all,
        %Ecto.Query{
          :aliases => _,
          :assocs => _,
          :combinations => _,
          :distinct => _,
          :from => _,
          :group_bys => _,
          :havings => _,
          :joins => _,
          :limit => _,
          :lock => _,
          :offset => _,
          :order_bys => _,
          :prefix => _,
          :preloads => _,
          :select => _,
          :sources => _,
          :updates => _,
          :wheres => _,
          :windows => _,
          :with_ctes => _
        }, Keyword.t()}
     | {:update_all,
        %Ecto.Query{
          :aliases => _,
          :assocs => _,
          :combinations => _,
          :distinct => _,
          :from => _,
          :group_bys => _,
          :havings => _,
          :joins => _,
          :limit => _,
          :lock => _,
          :offset => _,
          :order_bys => _,
          :prefix => _,
          :preloads => _,
          :select => _,
          :sources => _,
          :updates => _,
          :wheres => _,
          :windows => _,
          :with_ctes => _
        }, Keyword.t()}
     | {:insert_all, atom() | binary() | {binary(), atom()}, [Keyword.t() | map()],
        Keyword.t()}}
  ]
} which is violated by the success typing.

Success typing:
() :: %Ecto.Multi{:names => %MapSet{:map => %{}}, :operations => []}

________________________________________________________________________________
Please file a bug in https://github.com/jeremyjh/dialyxir/issues with this message.

Unknown error occurred: %FunctionClauseError{module: Dialyxir.Warnings.CallWithoutOpaque, function: :format_long, arity: 1, kind: nil, args: nil, clauses: nil}


Legacy warning:
lib/mapset_dialyzer.ex:8:16: The call 'Elixir.MapsetDialyzer':bar(#{'__struct__'=>'Elixir.MapSet', 'map'=>#{1=>[], 2=>[], 3=>[]}}) does not have a term of type #{'__struct__':='Elixir.MapSet', 'map':='Elixir.MapSet':internal(_)} (with opaque subterms) as 1st argument
________________________________________________________________________________
done (warnings were emitted)
Halting VM with exit status 2

[michallepicki]

If that helps here are opaqueness violations that Dialyzer finds in the Elixir codebase itself.

(personally I tried to understand this issue but gave up and I disable opaqueness checks in Dialyzer instead)

[josevalim]

Yes, I talked to the OTP team and it seems our options are:

1. Emit different code when running under dialyzer
2. Remove the opaque annotation

And both of them will have their own share of complexity and issues. My suggestion for now is indeed to disable the opaqueness checks, especially due to the fact structs are expanded at compile-time in the caller.

[michallepicki]

structs are expanded at compile-time in the caller

Is there some special inlining happening for MapSet.new/1? The MapsetDialyzer.foo/0 function doesn't create the struct with the literal syntax, it calls MapSet.new/1 which is annotated as returning MapSet.t (which does have an opaque "subterm" but it's an opaque subterm declared in the same module where the value is constructed, so I thought it should be fine...)

Also what I find odd is that I cannot reduce the problem by copy-pasting relevant bits to its own module, Dialyzer doesn't complain for:

defmodule MapsetDialyzer do
  @spec bar(MyMapSet.t()) :: term()
  def bar(set) do
    set
  end

  def foo() do
    bar(MyMapSet.new([1,2,3]))
  end
end

defmodule MyMapSet do
  @type value :: term

  @opaque internal(value) :: :sets.set(value)
  @type t(value) :: %__MODULE__{map: internal(value)}
  @type t :: t(term)

  defstruct map: :sets.new(version: 2)

  @spec new(Enumerable.t()) :: t
  def new(enumerable)

  def new(%__MODULE__{} = map_set), do: map_set

  def new(enumerable) do
    set =
      enumerable
      |> Enum.to_list()
      |> :sets.from_list(version: 2)

    %MyMapSet{map: set}
  end
end

[sabiwara]

@michallepicki yes https://github.com/elixir-lang/elixir/pull/13483/files

[josevalim]

Btw, I am not sure inlining in the same module would emit a violation, as it should allow opaque access within the same module?

So it is either:

1. disable inlining (decreasing performance)
2. remove opaque (making the docs/signatures less precise)
3. disable opaque checks from dialyzer

And it seems 3 may be the best option for now.

[sabiwara]

@josevalim agreed.

Perhaps option 4 could be to mark the result as generated, but this might impact the new type system so not ideal.

[josevalim]

Oh, perhaps if we annotate the inlined data structure as generated, Dialyzer won’t complain?

[michallepicki]

I don't know how marking as generated impacts dialyzer opaqueness analysis but since OTP 28 the dialyzer opaqueness violations are supposed to no longer "propagate" as "no-return" so they are not that annoying now