Merge pull request #20 from esl/types-elixir-pp

Pretty print Elixir types

Author: erszcz

lib/gradient/elixir_type.ex

@@ -2,19 +2,23 @@ defmodule Gradient.ElixirType do
   @moduledoc """
   Module to format types.
 
-  TODO records
-  FIXME add tests
+  Seems that:
+  - record type
+  - constrained function type
+  are not used by Elixir so the pp support has not been added.
   """
 
+  @type abstract_type() :: Gradient.Types.abstract_type()
+
   @doc """
   Take type and prepare a pretty string representation.
   """
-  @spec pretty_print(tuple()) :: String.t()
-  def pretty_print({:remote_type, _, [{:atom, _, mod}, {:atom, _, type}, args]}) do
+  @spec pretty_print(abstract_type()) :: String.t()
+  def pretty_print({:remote_type, _, [{:atom, _, mod}, {:atom, _, name}, args]}) do
     args_str = Enum.map(args, &pretty_print(&1)) |> Enum.join(", ")
-    type_str = Atom.to_string(type)
+    name_str = Atom.to_string(name)
     mod_str = parse_module(mod)
-    mod_str <> type_str <> "(#{args_str})"
+    mod_str <> name_str <> "(#{args_str})"
   end
 
   def pretty_print({:user_type, _, type, args}) do
@@ -24,7 +28,7 @@ defmodule Gradient.ElixirType do
   end
 
   def pretty_print({:ann_type, _, [var_name, var_type]}) do
-    pretty_print(var_name) <> pretty_print(var_type)
+    pretty_print(var_name) <> " :: " <> pretty_print(var_type)
   end
 
   def pretty_print({:type, _, :map, :any}) do
@@ -37,14 +41,18 @@ defmodule Gradient.ElixirType do
   end
 
   def pretty_print({:op, _, op, type}) do
-    Atom.to_string(op) <> pretty_print(type)
+    Atom.to_string(op) <> " " <> pretty_print(type)
   end
 
   def pretty_print({:op, _, op, left_type, right_type}) do
     operator = " " <> Atom.to_string(op) <> " "
     pretty_print(left_type) <> operator <> pretty_print(right_type)
   end
 
+  def pretty_print({:type, _, :fun, []}) do
+    "fun()"
+  end
+
   def pretty_print({:type, _, :fun, [{:type, _, :product, arg_types}, res_type]}) do
     args = Enum.map(arg_types, &pretty_print(&1)) |> Enum.join(", ")
     res = pretty_print(res_type)
@@ -56,6 +64,10 @@ defmodule Gradient.ElixirType do
     "(... -> " <> res <> ")"
   end
 
+  def pretty_print({:type, _, :range, [low, high]}) do
+    pretty_print(low) <> ".." <> pretty_print(high)
+  end
+
   def pretty_print({:type, _, :tuple, :any}) do
     "tuple()"
   end
@@ -65,11 +77,7 @@ defmodule Gradient.ElixirType do
     "{" <> elements_str <> "}"
   end
 
-  def pretty_print({:atom, _, nil}) do
-    "nil"
-  end
-
-  def pretty_print({:atom, _, val}) when val in [true, false] do
+  def pretty_print({:atom, _, val}) when val in [nil, true, false] do
     Atom.to_string(val)
   end
 
@@ -86,6 +94,7 @@ defmodule Gradient.ElixirType do
   end
 
   def pretty_print({:type, _, nil, []}) do
+    # The empty list type [] cannot be distinguished from the predefined type nil()
     "[]"
   end
 
@@ -102,6 +111,10 @@ defmodule Gradient.ElixirType do
     Atom.to_string(type) <> "(#{args_str})"
   end
 
+  def pretty_print({:var, _, t}) do
+    Atom.to_string(t)
+  end
+
   def pretty_print(type) do
     "#{inspect(type)}"
   end

lib/gradient/types.ex

@@ -1,6 +1,7 @@
 defmodule Gradient.Types do
   @type token :: tuple()
   @type tokens :: [tuple()]
+  @type abstract_type :: :erl_parse.abstract_type()
   @type form ::
           :erl_parse.abstract_clause()
           | :erl_parse.abstract_expr()

test/examples/type/Elixir.RecordEx.beam

@@ -0,0 +1,12 @@
+defmodule RecordEx do
+  require Record
+  Record.defrecord(:user, name: "john", age: 25)
+
+  @type user :: record(:user, name: String.t(), age: integer)
+
+  @spec ret_wrong_record() :: user()
+  def ret_wrong_record(), do: :ok
+
+  @spec ret_wrong_record2() :: user()
+  def ret_wrong_record2(), do: user(name: 12)
+end

test/examples/type/Elixir.WrongRet.beam

@@ -26,6 +26,26 @@ defmodule WrongRet do
   @spec ret_out_of_range_int() :: 1..10
   def ret_out_of_range_int, do: 12
 
+  @spec ret_wrong_float() :: float()
+  def ret_wrong_float() do
+    1
+  end
+
+  @spec ret_wrong_float2() :: float()
+  def ret_wrong_float2() do
+    nil
+  end
+
+  @spec ret_wrong_char() :: char()
+  def ret_wrong_char() do
+    'Ala ma kota'
+  end
+
+  @spec ret_wrong_char2() :: ?o
+  def ret_wrong_char2() do
+    nil
+  end
+
   @spec ret_wrong_boolean() :: boolean()
   def ret_wrong_boolean, do: :ok
 

test/examples/type/record.ex

@@ -9,7 +9,9 @@ defmodule Gradient.ElixirFmtTest do
   @example_module_path "test/examples/simple_app.ex"
 
   setup_all config do
-    load_wrong_ret_error_examples(config)
+    config
+    |> load_wrong_ret_error_examples()
+    |> load_record_type_example()
   end
 
   test "try_highlight_in_context/2" do
@@ -25,109 +27,152 @@ defmodule Gradient.ElixirFmtTest do
   end
 
   describe "types format" do
-    test "return integer() instead atom()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_atom)
+    test "return integer() instead of atom()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_atom)
 
-      assert String.contains?(msg, "atom()")
-      assert String.contains?(msg, "1")
+      assert String.contains?(expected, "atom()")
+      assert String.contains?(actual, "1")
     end
 
-    test "return tuple() instead atom()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_atom2)
+    test "return tuple() instead of atom()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_atom2)
 
-      assert String.contains?(msg, "atom()")
-      assert String.contains?(msg, "{:ok, []}")
+      assert String.contains?(expected, "atom()")
+      assert String.contains?(actual, "{:ok, []}")
     end
 
-    test "return map() instead atom()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_atom3)
+    test "return map() instead of atom()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_atom3)
 
-      assert String.contains?(msg, "atom()")
-      assert String.contains?(msg, "%{required(:a) => 1}")
+      assert String.contains?(expected, "atom()")
+      assert String.contains?(actual, "%{required(:a) => 1}")
     end
 
-    test "return float() instead integer()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_integer)
+    test "return float() instead of integer()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_integer)
 
-      assert String.contains?(msg, "integer()")
-      assert String.contains?(msg, "1.0")
+      assert String.contains?(expected, "integer()")
+      assert String.contains?(actual, "float()")
     end
 
-    test "return atom() instead integer()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_integer2)
+    test "return atom() instead of integer()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_integer2)
 
-      assert String.contains?(msg, "integer()")
-      assert String.contains?(msg, ":ok")
+      assert String.contains?(expected, "integer()")
+      assert String.contains?(actual, ":ok")
     end
 
-    test "return boolean() instead integer()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_integer3)
+    test "return boolean() instead of integer()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_integer3)
 
-      assert String.contains?(msg, "integer()")
-      assert String.contains?(msg, "true")
+      assert String.contains?(expected, "integer()")
+      assert String.contains?(actual, "true")
     end
 
-    test "return list() instead integer()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_integer4)
+    test "return list() instead of integer()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_integer4)
 
-      assert String.contains?(msg, "integer()")
-      assert String.contains?(msg, "nonempty_list()")
+      assert String.contains?(expected, "integer()")
+      assert String.contains?(actual, "nonempty_list()")
     end
 
     test "return integer() out of the range()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_out_of_range_int)
+      [expected, actual] = format_error_to_binary(errors.ret_out_of_range_int)
 
-      assert String.contains?(msg, "range(1, 10)")
-      assert String.contains?(msg, "12")
+      assert String.contains?(expected, "1..10")
+      assert String.contains?(actual, "12")
     end
 
-    test "return atom() instead boolean()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_boolean)
+    test "return integer() instead of float()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_float)
 
-      assert String.contains?(msg, "boolean()")
-      assert String.contains?(msg, ":ok")
+      assert String.contains?(expected, "float()")
+      assert String.contains?(actual, "1")
     end
 
-    test "return binary() instead boolean()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_boolean2)
+    test "return nil() instead of float()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_float2)
 
-      assert String.contains?(msg, "boolean()")
-      assert String.contains?(msg, "binary()")
+      assert String.contains?(expected, "float()")
+      assert String.contains?(actual, "nil")
     end
 
-    test "return integer() instead boolean()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_boolean3)
+    test "return charlist() instead of char()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_char)
 
-      assert String.contains?(msg, "boolean()")
-      assert String.contains?(msg, "1")
+      assert String.contains?(expected, "char()")
+      assert String.contains?(actual, "nonempty_list()")
     end
 
-    test "return keyword() instead boolean()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_boolean4)
+    test "return nil() instead of char()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_char2)
 
-      assert String.contains?(msg, "boolean()")
-      assert String.contains?(msg, "nonempty_list()")
+      # unfortunately char is represented as {:integer, 0, _}
+      assert String.contains?(expected, "111")
+      assert String.contains?(actual, "nil")
     end
 
-    test "return list() instead keyword()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_keyword)
+    test "return atom() instead of boolean()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_boolean)
 
-      assert String.contains?(msg, "{atom(), any()}")
-      assert String.contains?(msg, "1")
+      assert String.contains?(expected, "boolean()")
+      assert String.contains?(actual, ":ok")
     end
 
-    test "return tuple() instead map()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_map)
+    test "return binary() instead of boolean()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_boolean2)
 
-      assert String.contains?(msg, "map()")
-      assert String.contains?(msg, "{:a, 1, 2}")
+      assert String.contains?(expected, "boolean()")
+      assert String.contains?(actual, "binary()")
+    end
+
+    test "return integer() instead of boolean()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_boolean3)
+
+      assert String.contains?(expected, "boolean()")
+      assert String.contains?(actual, "1")
+    end
+
+    test "return keyword() instead of boolean()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_boolean4)
+
+      assert String.contains?(expected, "boolean()")
+      assert String.contains?(actual, "nonempty_list()")
+    end
+
+    test "return list() instead of keyword()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_keyword)
+
+      assert String.contains?(expected, "{atom(), any()}")
+      assert String.contains?(actual, "1")
+    end
+
+    test "return tuple() instead of map()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_map)
+
+      assert String.contains?(expected, "map()")
+      assert String.contains?(actual, "{:a, 1, 2}")
     end
 
     test "return lambda with wrong returned type", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_fun)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_fun)
+
+      assert String.contains?(expected, "atom()")
+      assert String.contains?(actual, "12")
+    end
 
-      assert String.contains?(msg, "atom()")
-      assert String.contains?(msg, "12")
+    test "return atom() instead of record()", %{record_type_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_record)
+
+      assert String.contains?(expected, "user()")
+      assert String.contains?(actual, ":ok")
+    end
+
+    test "return wrong record value type", %{record_type_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_record2)
+
+      assert String.contains?(expected, "String.t()")
+      assert String.contains?(actual, "12")
     end
   end
 
@@ -165,6 +210,26 @@ defmodule Gradient.ElixirFmtTest do
     error
     |> ElixirFmt.format_error(opts)
     |> :erlang.iolist_to_binary()
+    |> String.split("have type")
+    |> List.last()
+    |> String.split("but it has type")
+  end
+
+  @spec load_record_type_example(map()) :: map()
+  defp load_record_type_example(config) do
+    {_tokens, ast} = load("/type/Elixir.RecordEx.beam", "/type/record.ex")
+
+    {errors, forms} = type_check_file(ast, [])
+
+    names =
+      get_function_names_from_ast(forms)
+      |> Enum.drop(3)
+
+    errors_map =
+      Enum.zip(names, errors)
+      |> Map.new()
+
+    Map.put(config, :record_type_errors, errors_map)
   end
 
   @spec load_wrong_ret_error_examples(map()) :: map()