Merge pull request #27 from esl/finish-typespec

Finish typespec

Author: erszcz

lib/gradient/ast_specifier.ex

@@ -131,10 +131,11 @@ defmodule Gradient.AstSpecifier do
   @spec mapper(form(), [token()], options()) :: {form(), [token()]}
   def mapper(form, tokens, opts)
 
-  def mapper({:attribute, anno, :spec, {name_arity, specs}}, tokens, opts) do
+  def mapper({:attribute, anno, spec, {name_arity, specs}}, tokens, opts)
+      when spec in [:spec, :callback] do
     new_specs = context_mapper_map(specs, [], opts, &spec_mapper/3)
 
-    {:attribute, anno, :spec, {name_arity, new_specs}}
+    {:attribute, anno, spec, {name_arity, new_specs}}
     |> pass_tokens(tokens)
   end
 
@@ -478,6 +479,24 @@ defmodule Gradient.AstSpecifier do
     |> pass_tokens(tokens)
   end
 
+  def spec_mapper({:type, anno, :constraint, [subtype, vt]}, tokens, opts) do
+    {:ok, _, anno, opts, _} = get_line(anno, opts)
+    {subtype, _} = spec_mapper(subtype, tokens, opts)
+    vt = context_mapper_map(vt, tokens, opts, &spec_mapper/3)
+
+    {:type, anno, :constraint, [subtype, vt]}
+    |> pass_tokens(tokens)
+  end
+
+  def spec_mapper({:type, anno, :bounded_fun, [fn_type, when_type]}, tokens, opts) do
+    {:ok, _line, anno, opts, _} = get_line(anno, opts)
+    {fn_type, _} = spec_mapper(fn_type, tokens, opts)
+    when_type = context_mapper_map(when_type, tokens, opts, &spec_mapper/3)
+
+    {:type, anno, :bounded_fun, [fn_type, when_type]}
+    |> pass_tokens(tokens)
+  end
+
   def spec_mapper({:type, anno, type_name, args}, tokens, opts) do
     {:ok, _line, anno, opts, _} = get_line(anno, opts)
     new_args = context_mapper_map(args, tokens, opts, &spec_mapper/3)

test/examples/Elixir.Typespec.beam

@@ -1,18 +1,41 @@
 defmodule Typespec do
   @type mylist(t) :: [t]
 
-  @spec missing_type() :: Unknown.atom()
-  def missing_type, do: :ok
+  defstruct name: "", age: 1
 
-  @spec missing_type_arg() :: mylist(Unknown.atom())
-  def missing_type_arg, do: [:ok]
+  @spec spec_remote_type() :: Unknown.atom()
+  def spec_remote_type, do: :ok
 
-  @spec named_type(name :: Unknown.atom()) :: atom()
-  def named_type(name), do: name
+  @spec spec_user_type() :: mylist(:ok | atom())
+  def spec_user_type, do: [:ok]
 
-  @spec atoms_type(:ok | :error) :: :ok | :error
-  def atoms_type(name), do: name
+  @spec spec_map_and_named_type(type :: Unknown.atom()) :: %{
+          optional(:value) => integer(),
+          required(:type) => Unknown.atom()
+        }
+  def spec_map_and_named_type(type), do: %{type: type}
 
-  @spec atoms_type2(:ok | :error) :: Unknown.atom(:ok | :error)
-  def atoms_type2(name), do: name
+  @spec spec_atom(:ok | nil | true | false) :: Unknown.atom(:ok | nil | true | false)
+  def spec_atom(name), do: name
+
+  @spec spec_function() :: (atom(), %{name: String.t()} -> map())
+  def spec_function(), do: fn id, %{name: name} -> %{id: id, name: name} end
+
+  @spec spec_struct(%Typespec{}) :: %Typespec{}
+  def spec_struct(struct), do: struct
+
+  @spec spec_list([integer(), ...]) :: [...]
+  def spec_list(list), do: list
+
+  @spec spec_range(1..10) :: [1..10]
+  def spec_range(i), do: [i]
+
+  @spec spec_keyword(a: integer(), b: integer()) :: integer()
+  def spec_keyword(a: a, b: b), do: a + b
+
+  @spec spec_tuple({:ok, integer()}) :: tuple()
+  def spec_tuple({:ok, a}), do: {:ok, a + 1}
+
+  @spec spec_bitstring(<<_::48, _::_*8>>) :: <<>>
+  def spec_bitstring(_), do: <<>>
 end

test/examples/Elixir.TypespecBeh.beam

@@ -0,0 +1,6 @@
+defmodule TypespecBeh do
+  @callback vital_fun() :: %{atom() => any()}
+  @callback non_vital_fun() :: a when a: {integer(), atom()}
+  @macrocallback non_vital_macro(arg :: any) :: Macro.t()
+  @optional_callbacks non_vital_fun: 0, non_vital_macro: 1
+end

test/examples/Elixir.TypespecWhen.beam

@@ -0,0 +1,12 @@
+defmodule TypespecWhen do
+  @spec foo({:a, x}) :: {:a, x} | {:b, x} when x: term()
+  def foo({:a, x}) do
+    case x do
+      :foo ->
+        {:a, x}
+
+      _ ->
+        {:b, x}
+    end
+  end
+end