Render improper list types as such

Author: sabiwara

lib/elixir/lib/module/types/descr.ex

@@ -75,6 +75,9 @@ defmodule Module.Types.Descr do
   def fun(), do: %{bitmap: @bit_fun}
   def list(type), do: list_descr(type, @empty_list, true)
   def non_empty_list(type, tail \\ @empty_list), do: list_descr(type, tail, false)
+  def improper_list(), do: improper_list(term(), term())
+  def improper_list(type, :term), do: list_descr(type, @not_list, false)
+  def improper_list(type, tail), do: list_descr(type, difference(tail, list(term())), false)
   def open_map(), do: %{map: @map_top}
   def open_map(pairs), do: map_descr(:open, pairs)
   def open_tuple(elements, _fallback \\ term()), do: tuple_descr(:open, elements)
@@ -1078,27 +1081,30 @@ defmodule Module.Types.Descr do
 
   defp list_tl_static(%{}), do: none()
 
-  defp list_improper_static?(:term), do: false
-  defp list_improper_static?(%{bitmap: bitmap}) when (bitmap &&& @bit_empty_list) != 0, do: false
-  defp list_improper_static?(term), do: equal?(term, @not_list)
+  defp list_improper_term?(:term), do: true
+  defp list_improper_term?(term), do: equal?(term, @not_list) or equal?(term, @not_non_empty_list)
 
   defp list_to_quoted(dnf, empty?, opts) do
     dnf = list_normalize(dnf)
 
     {unions, list_rendered?} =
       Enum.reduce(dnf, {[], false}, fn {list_type, last_type, negs}, {acc, list_rendered?} ->
         {name, arguments, list_rendered?} =
-          cond do
-            list_type == term() and list_improper_static?(last_type) ->
-              {:improper_list, [], list_rendered?}
+          if subtype?(last_type, @empty_list) do
+            name = if empty?, do: :list, else: :non_empty_list
+            {name, [to_quoted(list_type, opts)], empty?}
+          else
+            type =
+              if subtype?(@empty_list, last_type),
+                do: :non_empty_maybe_improper_list,
+                else: :improper_list
 
-            subtype?(last_type, @empty_list) ->
-              name = if empty?, do: :list, else: :non_empty_list
-              {name, [to_quoted(list_type, opts)], empty?}
+            # mark improper_list(term(), term()) as such rather than:
+            # improper_list(term(), atom() or binary() or float() or ...)
+            rendered_last_type = if list_improper_term?(last_type), do: :term, else: last_type
 
-            true ->
-              args = [to_quoted(list_type, opts), to_quoted(last_type, opts)]
-              {:non_empty_list, args, list_rendered?}
+            args = [to_quoted(list_type, opts), to_quoted(rendered_last_type, opts)]
+            {type, args, list_rendered?}
           end
 
         acc =

lib/elixir/test/elixir/module/types/descr_test.exs

@@ -1298,17 +1298,42 @@ defmodule Module.Types.DescrTest do
              |> to_quoted_string() ==
                "non_empty_list(term()) and not (non_empty_list(atom()) or non_empty_list(integer()))"
 
+      assert list(integer()) |> union(list(atom())) |> to_quoted_string() ==
+               "list(atom()) or list(integer())"
+
+      assert list(integer())
+             |> union(list(atom()))
+             |> difference(empty_list())
+             |> to_quoted_string() ==
+               "non_empty_list(atom()) or non_empty_list(integer())"
+
       assert list(term(), integer()) |> to_quoted_string() ==
-               "empty_list() or non_empty_list(term(), integer())"
+               "empty_list() or improper_list(term(), integer())"
 
       assert difference(list(term(), atom()), list(term(), boolean())) |> to_quoted_string() ==
-               "non_empty_list(term(), atom() and not boolean())"
+               "improper_list(term(), atom() and not boolean())"
 
       assert list(term(), term()) |> to_quoted_string() ==
-               "empty_list() or non_empty_list(term(), term())"
+               "empty_list() or non_empty_maybe_improper_list(term(), term())"
+
+      assert improper_list(term(), term()) |> to_quoted_string() ==
+               "improper_list(term(), term())"
+
+      assert improper_list(integer(), integer()) |> to_quoted_string() ==
+               "improper_list(integer(), integer())"
+
+      assert union(empty_list(), improper_list(integer(), integer())) |> to_quoted_string() ==
+               "empty_list() or improper_list(integer(), integer())"
+
+      assert union(non_empty_list(integer()), improper_list(integer(), integer()))
+             |> to_quoted_string() ==
+               "non_empty_maybe_improper_list(integer(), empty_list() or integer())"
+
+      assert union(list(integer()), improper_list(integer(), integer())) |> to_quoted_string() ==
+               "empty_list() or non_empty_maybe_improper_list(integer(), empty_list() or integer())"
 
-      assert non_empty_list(term(), difference(term(), list(term()))) |> to_quoted_string() ==
-               "improper_list()"
+      assert union(list(term()), improper_list(term(), term())) |> to_quoted_string() ==
+               "empty_list() or non_empty_maybe_improper_list(term(), term())"
 
       # Test normalization
 
@@ -1317,15 +1342,15 @@ defmodule Module.Types.DescrTest do
 
       # Merge subtypes
       assert union(list(float(), pid()), list(number(), pid())) |> to_quoted_string() ==
-               "empty_list() or non_empty_list(float() or integer(), pid())"
+               "empty_list() or improper_list(float() or integer(), pid())"
 
       # Merge last element types
       assert union(list(atom([:ok]), integer()), list(atom([:ok]), float())) |> to_quoted_string() ==
-               "empty_list() or non_empty_list(:ok, float() or integer())"
+               "empty_list() or improper_list(:ok, float() or integer())"
 
       assert union(dynamic(list(integer(), float())), dynamic(list(integer(), pid())))
              |> to_quoted_string() ==
-               "dynamic(empty_list() or non_empty_list(integer(), float() or pid()))"
+               "dynamic(empty_list() or improper_list(integer(), float() or pid()))"
     end
 
     test "tuples" do