contract translator extracted to separate module (elixir-editors#462)

tests added
fix %{optional(atom)=>any} being translated to %{} - should be map
do not translate %Struct{} to Struct.t if Struct.t does not exist
added tweaks for fun(), list() and struct()
Fixes elixir-editors#425

Author: lukaszsamson

apps/language_server/lib/language_server/providers/code_lens/type_spec.ex

@@ -12,103 +12,7 @@ defmodule ElixirLS.LanguageServer.Providers.CodeLens.TypeSpec do
 
   alias ElixirLS.LanguageServer.Providers.CodeLens
   alias ElixirLS.LanguageServer.{Server, SourceFile}
-  alias Erl2ex.Convert.{Context, ErlForms}
-  alias Erl2ex.Pipeline.{Parse, ModuleData, ExSpec}
-
-  defmodule ContractTranslator do
-    def translate_contract(fun, contract, is_macro) do
-      # FIXME: Private module
-      {[%ExSpec{specs: [spec]} | _], _} =
-        "-spec foo#{contract}."
-        # FIXME: Private module
-        |> Parse.string()
-        |> hd()
-        |> elem(0)
-        # FIXME: Private module
-        |> ErlForms.conv_form(%Context{
-          in_type_expr: true,
-          # FIXME: Private module
-          module_data: %ModuleData{}
-        })
-
-      spec
-      |> Macro.postwalk(&tweak_specs/1)
-      |> drop_macro_env(is_macro)
-      |> Macro.to_string()
-      |> String.replace("()", "")
-      |> Code.format_string!(line_length: :infinity)
-      |> IO.iodata_to_binary()
-      |> String.replace_prefix("foo", to_string(fun))
-    end
-
-    defp tweak_specs({:list, _meta, args}) do
-      case args do
-        [{:{}, _, [{:atom, _, []}, {wild, _, _}]}] when wild in [:_, :any] -> quote do: keyword()
-        list -> list
-      end
-    end
-
-    defp tweak_specs({:nonempty_list, _meta, args}) do
-      case args do
-        [{:any, _, []}] -> quote do: [...]
-        _ -> args ++ quote do: [...]
-      end
-    end
-
-    defp tweak_specs({:%{}, _meta, fields}) do
-      fields =
-        Enum.map(fields, fn
-          {:map_field_exact, _, [key, value]} -> {key, value}
-          {key, value} -> quote do: {optional(unquote(key)), unquote(value)}
-          field -> field
-        end)
-        |> Enum.reject(&match?({{:optional, _, [{:any, _, []}]}, {:any, _, []}}, &1))
-
-      fields
-      |> Enum.find_value(fn
-        {:__struct__, struct_type} when is_atom(struct_type) -> struct_type
-        _ -> nil
-      end)
-      |> case do
-        nil -> {:%{}, [], fields}
-        struct_type -> {{:., [], [struct_type, :t]}, [], []}
-      end
-    end
-
-    # Undo conversion of _ to any() when inside binary spec
-    defp tweak_specs({:<<>>, _, children}) do
-      children =
-        Macro.postwalk(children, fn
-          {:any, _, []} -> quote do: _
-          other -> other
-        end)
-
-      {:<<>>, [], children}
-    end
-
-    defp tweak_specs({:_, _, _}) do
-      quote do: any()
-    end
-
-    defp tweak_specs({:when, [], [spec, substitutions]}) do
-      substitutions = Enum.reject(substitutions, &match?({:_, {:any, _, []}}, &1))
-
-      case substitutions do
-        [] -> spec
-        _ -> {:when, [], [spec, substitutions]}
-      end
-    end
-
-    defp tweak_specs(node) do
-      node
-    end
-
-    defp drop_macro_env(ast, false), do: ast
-
-    defp drop_macro_env({:"::", [], [{:foo, [], [_env | rest]}, res]}, true) do
-      {:"::", [], [{:foo, [], rest}, res]}
-    end
-  end
+  alias ElixirLS.LanguageServer.Providers.CodeLens.TypeSpec.ContractTranslator
 
   def code_lens(server_instance_id, uri, text) do
     resp =

apps/language_server/lib/language_server/providers/code_lens/type_spec/contract_translator.ex

@@ -0,0 +1,139 @@
+defmodule ElixirLS.LanguageServer.Providers.CodeLens.TypeSpec.ContractTranslator do
+  @moduledoc false
+  alias Erl2ex.Convert.{Context, ErlForms}
+  alias Erl2ex.Pipeline.{Parse, ModuleData, ExSpec}
+
+  def translate_contract(fun, contract, is_macro) do
+    # FIXME: Private module
+    {[%ExSpec{specs: [spec]} | _], _} =
+      "-spec foo#{contract}."
+      # FIXME: Private module
+      |> Parse.string()
+      |> hd()
+      |> elem(0)
+      # FIXME: Private module
+      |> ErlForms.conv_form(%Context{
+        in_type_expr: true,
+        # FIXME: Private module
+        module_data: %ModuleData{}
+      })
+
+    spec
+    |> Macro.postwalk(&tweak_specs/1)
+    |> drop_macro_env(is_macro)
+    |> Macro.to_string()
+    |> String.replace("()", "")
+    |> Code.format_string!(line_length: :infinity)
+    |> IO.iodata_to_binary()
+    |> String.replace_prefix("foo", to_string(fun))
+  end
+
+  defp tweak_specs({:list, _meta, args}) do
+    case args do
+      [{:{}, _, [{:atom, _, []}, {wild, _, _}]}] when wild in [:_, :any] -> quote do: keyword()
+      [{:{}, _, [{:atom, _, []}, other]}] -> quote do: keyword(unquote(other))
+      [{:any, _, []}] -> quote do: list()
+      list -> list
+    end
+  end
+
+  defp tweak_specs({:nonempty_list, _meta, args}) do
+    case args do
+      [{:any, _, []}] -> quote do: [...]
+      _ -> args ++ quote do: [...]
+    end
+  end
+
+  defp tweak_specs({:%{}, _meta, fields}) do
+    fields =
+      Enum.map(fields, fn
+        {:map_field_exact, _, [key, value]} -> {key, value}
+        {key, value} -> quote do: {optional(unquote(key)), unquote(value)}
+        field -> field
+      end)
+
+    translate_map(fields)
+  end
+
+  # Undo conversion of _ to any() when inside binary spec
+  defp tweak_specs({:<<>>, _, children}) do
+    children =
+      Macro.postwalk(children, fn
+        {:any, _, []} -> quote do: _
+        other -> other
+      end)
+
+    {:<<>>, [], children}
+  end
+
+  defp tweak_specs({:_, _, _}) do
+    quote do: any()
+  end
+
+  defp tweak_specs({:when, [], [spec, substitutions]}) do
+    substitutions = Enum.reject(substitutions, &match?({:_, {:any, _, []}}, &1))
+
+    case substitutions do
+      [] -> spec
+      _ -> {:when, [], [spec, substitutions]}
+    end
+  end
+
+  defp tweak_specs([{:->, _, [[{:..., _, _}], {:any, _, []}]}]) do
+    quote do: fun()
+  end
+
+  defp tweak_specs(node) do
+    node
+  end
+
+  defp drop_macro_env(ast, false), do: ast
+
+  defp drop_macro_env({:"::", [], [{:foo, [], [_env | rest]}, res]}, true) do
+    {:"::", [], [{:foo, [], rest}, res]}
+  end
+
+  defp translate_map([
+         {:__struct__, {:atom, _, []}},
+         {{:optional, _, [{:atom, _, []}]}, {:any, _, []}}
+       ]) do
+    quote do: struct()
+  end
+
+  defp translate_map([
+         {{:optional, _, [{:any, _, []}]}, {:any, _, []}}
+       ]) do
+    quote do: map()
+  end
+
+  defp translate_map(fields) do
+    struct_type =
+      fields
+      |> Enum.find_value(fn
+        {:__struct__, struct_type} when is_atom(struct_type) -> struct_type
+        _ -> nil
+      end)
+
+    translate_map(struct_type, fields)
+  end
+
+  defp translate_map(nil, fields) do
+    {:%{}, [], fields}
+  end
+
+  defp translate_map(struct_type, fields) do
+    struct_type_spec_exists =
+      ElixirSense.Core.Normalized.Typespec.get_types(struct_type)
+      |> Enum.any?(&match?({kind, {:t, _, []}} when kind in [:type, :opaque], &1))
+
+    if struct_type_spec_exists do
+      # struct_type.t/0 public/opaque type exists, assume it's a struct
+      {{:., [], [struct_type, :t]}, [], []}
+    else
+      # translate map AST to struct AST
+      fields = fields |> Enum.reject(&match?({:__struct__, _}, &1))
+      map = {:%{}, [], fields}
+      {:%, [], [struct_type, map]}
+    end
+  end
+end

apps/language_server/test/providers/code_lens/type_spec/contract_translator_test.exs

@@ -0,0 +1,134 @@
+defmodule ElixirLS.LanguageServer.Providers.CodeLens.TypeSpec.ContractTranslatorTest do
+  use ExUnit.Case, async: true
+  alias ElixirLS.LanguageServer.Providers.CodeLens.TypeSpec.ContractTranslator
+
+  test "translate struct when struct.t type exists" do
+    contract = '() -> \#{\'__struct__\':=\'Elixir.DateTime\'}'
+    assert "foo :: DateTime.t()" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "don't translate struct when struct.t type does not exist" do
+    contract = '() -> \#{\'__struct__\':=\'Elixir.SomeOtherStruct\'}'
+
+    assert "foo :: %SomeOtherStruct{}" ==
+             ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "struct" do
+    contract = '() -> \#{\'__struct__\':=atom(), atom()=>any()}'
+    assert "foo :: struct" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "drop macro env argument" do
+    contract = '(any(), integer()) -> integer()'
+
+    assert "foo(any, integer) :: integer" ==
+             ContractTranslator.translate_contract(:foo, contract, false)
+
+    assert "foo(integer) :: integer" ==
+             ContractTranslator.translate_contract(:foo, contract, true)
+  end
+
+  test "atom :ok" do
+    contract = '(any()) -> ok'
+    assert "foo(any) :: :ok" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "atom true" do
+    contract = '(any()) -> true'
+    assert "foo(any) :: true" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "atom _ substitution" do
+    contract = '(_) -> false'
+    assert "foo(any) :: false" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "do not drop when substitutions" do
+    contract = '(X) -> atom() when X :: any()'
+
+    assert "foo(x) :: atom when x: any" ==
+             ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "keyword" do
+    contract = '(any()) -> list({atom(), any()})'
+    assert "foo(any) :: keyword" == ContractTranslator.translate_contract(:foo, contract, false)
+
+    contract = '(any()) -> list({atom(), _})'
+    assert "foo(any) :: keyword" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "keyword(t)" do
+    contract = '(any()) -> list({atom(), integer()})'
+
+    assert "foo(any) :: keyword(integer)" ==
+             ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "[type]" do
+    contract = '(any()) -> list(atom())'
+    assert "foo(any) :: [atom]" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "list" do
+    contract = '(any()) -> list(any())'
+    assert "foo(any) :: list" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "empty list" do
+    contract = '(any()) -> []'
+    assert "foo(any) :: []" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "[...]" do
+    contract = '(any()) -> nonempty_list(any())'
+    assert "foo(any) :: [...]" == ContractTranslator.translate_contract(:foo, contract, false)
+
+    contract = '(any()) -> nonempty_list(_)'
+    assert "foo(any) :: [...]" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "[type, ...]" do
+    contract = '(any()) -> nonempty_list(atom())'
+
+    assert "foo(any) :: [atom, ...]" ==
+             ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "undoes conversion of :_ to any inside bitstring" do
+    contract = '(any()) -> <<_:2, _:_*3>>'
+
+    assert "foo(any) :: <<_::2, _::_*3>>" ==
+             ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "function" do
+    contract = '(any()) -> fun((...) -> ok)'
+
+    assert "foo(any) :: (... -> :ok)" ==
+             ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "fun" do
+    contract = '(any()) -> fun((...) -> any())'
+    assert "foo(any) :: fun" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "empty map" do
+    contract = '(any()) -> \#{}'
+    assert "foo(any) :: %{}" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "map" do
+    contract = '(any()) -> \#{any()=>any()}'
+    assert "foo(any) :: map" == ContractTranslator.translate_contract(:foo, contract, false)
+  end
+
+  test "map with fields" do
+    contract = '(any()) -> \#{integer()=>any(), 1:=atom(), abc:=4}'
+
+    assert "foo(any) :: %{optional(integer) => any, 1 => atom, :abc => 4}" ==
+             ContractTranslator.translate_contract(:foo, contract, false)
+  end
+end