Dialyzer warning about nil missing from spec

[JanEricNitschke]

Hi,

i have these functions

  @spec ai_random_move(board_t()) :: integer()
  def ai_random_move(board) do
    Enum.random(empty_spots(board))
  end

  @spec try_win_move(board_t(), String.t()) :: integer() | nil
  def try_win_move(board, player) do
    Enum.find(empty_spots(board), &winner?(make_move(board, &1, player), player))
  end

  @spec ai_win_move(board_t(), String.t()) :: integer()
  def ai_win_move(board, player) do
    try_win_move(board, player) || ai_random_move(board)
  end

and i am getting a warning from dialyzer

lib/tictactoe_elixir.ex:154:missing_range
The type specification is missing types returned by function.

Function:
TictactoeElixir.ai_win_move/2

Type specification return types:
integer()

Missing from spec:
nil

This does not seem correct to me, as the nil can never actually be returned due to the ||. Is this a shortcoming of dialyzer or am i doing something wrong here?

[garazdawi]

Hello! We only have a very basic understanding of Elixir, so it would help a lot if you could translate the example to Erlang.

[jhogberg]

Thanks for your report! This is not a warning that is enabled by default, but one that you specifically have to opt into because it may give false positives like this one. I'm inclined to believe that this is such a false positive, but if you can reduce this to an Erlang example I'll happily take a look to be sure.

[JanEricNitschke]

Hi,

unfortunately i am not sure what the simplest erlang translation is that also exhibits the issue.

What this boils down to is that i have an expression (integer | nil) || integer.

Where || is the short circuiting or in elixir which treats nil as falsey. So this should only every return an integer but it is still being flagged as potentially returning nil.

[jhogberg]

What this boils down to is that i have an expression (integer | nil) || integer.

Where || is the short circuiting or in elixir which treats nil as falsey. So this should only every return an integer but it is still being flagged as potentially returning nil.

Yes, however, || may be expressed (as Erlang code) in a manner that makes dialyzer miss this fact. I'd need to have a look at the expansion to Erlang code to know for certain whether this is a false positive or a bug.

[JanEricNitschke]

Yeah, makes sense. Ill try to look around if i can find what erlang code this is transpiled to.

[JanEricNitschke]

Ok so i now reduced it to this standalone elixir code:

defmodule Stuff do
  @spec f1(boolean()) :: integer() | nil
  def f1(arg) do
    cond do
      arg -> 3
      true -> nil
    end
  end

  @spec f2() :: 5
  def f2() do
    3 + 2
  end

  @spec f3() :: integer()
  def f3() do
    f1(true) || f2()
  end
end

Decompiled it to erlang with this: https://github.com/michalmuskala/decompile

and got this:

-file("lib/text.ex", 1).

-module('Elixir.Stuff').

-compile([no_auto_import]).

-spec f3() -> integer().

-spec f2() -> 5.

-spec f1(boolean()) -> integer() | nil.

-export(['__info__'/1,f1/1,f2/0,f3/0]).

-spec '__info__'(attributes | compile | functions | macros | md5 |
                 module | deprecated | struct) ->
                    any().

'__info__'(module) ->
    'Elixir.Stuff';
'__info__'(functions) ->
    [{f1, 1}, {f2, 0}, {f3, 0}];
'__info__'(macros) ->
    [];
'__info__'(struct) ->
    nil;
'__info__'(Key = attributes) ->
    erlang:get_module_info('Elixir.Stuff', Key);
'__info__'(Key = compile) ->
    erlang:get_module_info('Elixir.Stuff', Key);
'__info__'(Key = md5) ->
    erlang:get_module_info('Elixir.Stuff', Key);
'__info__'(deprecated) ->
    [].

f1(_arg@1) ->
    case _arg@1 of
        _@1
            when
                _@1 /= nil
                andalso
                _@1 /= false ->
            3;
        _ ->
            case true of
                true ->
                    nil
            end
    end.

f2() ->
    3 + 2.

f3() ->
    case f1(true) of
        _@1
            when
                _@1 =:= false
                orelse
                _@1 =:= nil ->
            f2();
        _@2 ->
            _@2
    end.

Running this through dialyzer -Wunmatched_returns -Werror_handling -Wunderspecs -Wextra_return -Wmissing_return --src Elixir.Stuff.erl

gives:

text.ex:7:2: The success typing for 'Elixir.Stuff':f3/0 implies that the function might also return
          'nil' but the specification return is
          integer()

[jhogberg]

Thanks! This is a shortcoming in dialyzer that cannot be fixed in the general case, if you don't want warnings that may be false positives, stop providing -Wunderspecs -Wextra_return -Wmissing_return.

[JanEricNitschke]

Ok, thanks a lot for the information. I think i will keep these arguments but just suppress them in the cases where i can verify that they are false positives.

Just wanted to verify that these are indeed false positives and that i didnt miss anything and also that they arent easy to address on your side.

Thanks again!