Double Specs not taken into account

[Fl4m3Ph03n1x]

Background

I have a module of pure functions where I am adding specs. In one of my specs I have the wrong function name:

defmodule ImmutableValues do

  @spec first_two([String.t()]) :: [String.t()]
  def first_two([first, second | _tail]), do: [first, second]

  @spec first_two([String.t()]) :: [String.t()]
  def last_two(list) do
    [last, penultimate | _tail] = Enum.reverse(list)
    [penultimate, last]
  end

end

This means two things:

• I have no spec for last_two
• first_two has a double spec

Actual behaviour

mix gradient
Compiling 1 file (.ex)
Typechecking files...
No problems found!

Expected behaviour

Now, obviously I made this mistake by copy pasting specs. However, I expected one of the two possible errors:

• A message complaining that last_two has a missing spec
• A message complaining that first_two has a double spec

What would be really awesome would be the tool detecting that the spec I intended for last_two is likely incorrectly named (perhaps this would be possible by checking the line number of the spec and the line number of the function declaration).

Dialyzer goes for option 2, complaining about a duplicate spec.

Why am I reporting this?

It is my personal opinion that the current implementation that detects no errors is incorrect. At least from a user's point of view, it makes little sense.

[erszcz]

Interesting. Indeed, the current implementation doesn't detect this. It's likely because the Erlang compiler detects this problem and treats it as a terminal error - therefore Gradualizer, the typechecker backend used by Gradient, doesn't have to worry about it:

$ cat z.erl
-module(z).

-spec first_two([binary()]) -> [binary()].
first_two([F, S | _]) ->
    [F, S].

-spec first_two([binary()]) -> [binary()].
last_two(L) -> [].
$ erlc z.erl
z.erl:7:2: spec for first_two/1 already defined
%    7| -spec first_two([binary()]) -> [binary()].
%     |  ^

z.erl:4:1: Warning: function first_two/1 is unused
%    4| first_two([F, S | _]) ->
%     | ^

z.erl:8:1: Warning: function last_two/1 is unused
%    8| last_two(L) -> [].
%     | ^

z.erl:8:10: Warning: variable 'L' is unused
%    8| last_two(L) -> [].
%     |          ^

We'll have to add this check for Elixir in Gradient itself or suggest adding it upstream in the compiler. Good catch, @Fl4m3Ph03n1x, thanks for reporting it!

[Premwoik]

We can introduce a check whether the spec is above the function that it refers to. In Elixir we can have multiple spec for a function:

@spec convert(integer()) :: float()
def convert(int) when is_integer(int), do: int / 1
@spec convert(atom()) :: binary()
def convert(atom) when is_atom(atom), do: to_string(atom)

and the Erlang equivalent:

-spec convert(integer()) -> float();
             (atom()) -> binary().

and the produced AST

{:attribute, 2, :spec,
 {{:convert, 1},
  [
    {:type, 2, :fun,
     [
       {:type, 2, :product, [{:type, 2, :integer, []}]},
       {:type, 2, :float, []}
     ]},
    {:type, 4, :fun,
     [
       {:type, 4, :product, [{:type, 4, :atom, []}]},
       {:type, 4, :binary, []}
     ]}
  ]}},

Indeed in Erlang, we cannot have multiple -spec, but in Elixir syntax that uses attributes, it is allowed.