Convert list_proper? into list_of

Author: josevalim

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

@@ -1879,45 +1879,113 @@ defmodule Module.Types.Descr do
   defp list_top?(_), do: false
 
   @doc """
-  Checks if a list type is a proper list (terminated by empty list).
+  Returns the element type of a list, assuming the list is proper.
+
+  It returns a two-element tuple. The first element dictates the
+  empty list type. The second element returns the value type.
+
+      {:static or :dynamic or nil, t() or nil}
+
+  If the value is `nil`, it means that component is missing.
+  However, both cannot be `nil` together. In such cases,
+  we return `:badproperlist`.
   """
-  def list_proper?(:term), do: false
+  def list_of(:term), do: :badproperlist
 
-  def list_proper?(descr) do
-    {dynamic, static} = Map.pop(descr, :dynamic, descr)
+  def list_of(descr) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        with {empty_list, value} <- list_of_static(descr) do
+          if empty?(value) and empty_list == nil do
+            :badproperlist
+          else
+            {empty_list, value}
+          end
+        end
 
-    # A list is proper if it's either the empty list alone, or all non-empty
-    # list types have tails that are subtypes of empty list.
-    case static do
-      %{list: bdd} ->
-        Map.get(static, :bitmap, @bit_empty_list) == @bit_empty_list and
-          empty?(Map.drop(static, [:list, :bitmap])) and
-          list_bdd_to_pos_dnf(bdd)
-          |> Enum.all?(fn {_list, last, _negs} -> subtype?(last, @empty_list) end)
+      {dynamic, static} ->
+        with {empty_list, static_value} <- list_of_static(static) do
+          empty_list =
+            case dynamic do
+              %{bitmap: bitmap} when (bitmap &&& @bit_empty_list) != 0 -> :dynamic
+              _ -> empty_list
+            end
 
-      _ when static == %{bitmap: @bit_empty_list} ->
-        true
+          dynamic_value =
+            case dynamic do
+              :term ->
+                dynamic()
+
+              %{list: bdd} ->
+                Enum.reduce(list_bdd_to_pos_dnf(bdd), none(), fn {list, last, _negs}, acc ->
+                  if last == @empty_list or subtype?(last, @empty_list) do
+                    union(acc, list)
+                  else
+                    acc
+                  end
+                end)
+
+              %{} ->
+                none()
+            end
 
-      %{} ->
-        # Dynamic requires only the empty list or a single proper list
-        empty?(static) and
-          case dynamic do
-            :term ->
-              true
+          if empty?(dynamic_value) do
+            # list_bdd_to_pos_dnf guarantees the lists actually exists,
+            # so we can match on none() rather than empty.
+            if empty_list == nil do
+              :badproperlist
+            else
+              {empty_list, nil}
+            end
+          else
+            {empty_list, union(static_value, dynamic(dynamic_value))}
+          end
+        end
+    end
+  end
 
-            %{bitmap: bitmap} when (bitmap &&& @bit_empty_list) != 0 ->
-              true
+  defp list_of_static(descr) do
+    case descr do
+      %{bitmap: @bit_empty_list} ->
+        case empty?(Map.drop(descr, [:bitmap, :list])) do
+          true -> list_of_static(descr, :static)
+          false -> :badproperlist
+        end
 
-            %{list: bdd} ->
-              list_bdd_to_pos_dnf(bdd)
-              |> Enum.any?(fn {_list, last, _negs} -> subtype?(last, @empty_list) end)
+      %{bitmap: _} ->
+        :badproperlist
 
-            %{} ->
-              false
+      %{} ->
+        case empty?(Map.delete(descr, :list)) do
+          true -> list_of_static(descr, nil)
+          false -> :badproperlist
+        end
+    end
+  end
+
+  # A list is proper if it's either the empty list alone, or all non-empty
+  # list types have tails that are subtypes of empty list.
+  defp list_of_static(%{list: bdd}, empty_list) do
+    try do
+      result =
+        Enum.reduce(list_bdd_to_pos_dnf(bdd), none(), fn {list, last, _negs}, acc ->
+          if last == @empty_list or subtype?(last, @empty_list) do
+            union(acc, list)
+          else
+            throw(:badproperlist)
           end
+        end)
+
+      {empty_list, result}
+    catch
+      :badproperlist -> :badproperlist
     end
   end
 
+  defp list_of_static(%{}, empty_list) do
+    {empty_list, none()}
+  end
+
   defp list_intersection(bdd_leaf(list1, last1), bdd_leaf(list2, last2)) do
     try do
       list = non_empty_intersection!(list1, list2)

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

@@ -1268,26 +1268,29 @@ defmodule Module.Types.DescrTest do
       assert list_hd(non_empty_list(atom(), negation(list(term(), term())))) == {:ok, atom()}
     end
 
-    test "list_proper?" do
-      refute list_proper?(term())
-      refute list_proper?(none())
-      assert list_proper?(empty_list())
-      assert list_proper?(non_empty_list(integer()))
-      refute list_proper?(non_empty_list(integer(), atom()))
-      refute list_proper?(non_empty_list(integer(), term()))
-      assert list_proper?(non_empty_list(integer(), list(term())))
-      refute list_proper?(list(integer()) |> union(list(integer(), integer())))
-      assert list_proper?(dynamic(list(integer())))
-      assert list_proper?(dynamic(list(integer(), atom())))
-      refute list_proper?(dynamic(non_empty_list(integer(), atom())))
-
-      # An empty list
+    test "list_of" do
+      assert list_of(term()) == :badproperlist
+      assert list_of(none()) == :badproperlist
+      assert list_of(empty_list()) == {:static, none()}
+      assert list_of(union(empty_list(), integer())) == :badproperlist
+      assert list_of(non_empty_list(integer())) == {nil, integer()}
+      assert list_of(non_empty_list(integer(), atom())) == :badproperlist
+      assert list_of(non_empty_list(integer(), term())) == :badproperlist
+      assert list_of(non_empty_list(integer(), list(term()))) == {nil, term()}
+      assert list_of(list(integer()) |> union(list(integer(), integer()))) == :badproperlist
+      assert list_of(list(integer()) |> union(integer())) == :badproperlist
+      assert list_of(dynamic(list(integer()))) == {:dynamic, dynamic(integer())}
+      assert list_of(dynamic(list(integer(), atom()))) == {:dynamic, nil}
+      assert list_of(dynamic(non_empty_list(integer(), atom()))) == :badproperlist
+      assert list_of(dynamic(union(empty_list(), integer()))) == {:dynamic, nil}
+
+      # A list that the difference resolves to nothing
       list_with_tail =
         non_empty_list(atom(), union(integer(), empty_list()))
         |> difference(non_empty_list(atom([:ok]), integer()))
         |> difference(non_empty_list(atom(), term()))
 
-      assert list_proper?(list_with_tail)
+      assert list_of(list_with_tail) == :badproperlist
     end
 
     test "list_tl" do