Add map_to_list

Author: gldubc

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

@@ -51,6 +51,7 @@ defmodule Module.Types.Descr do
     list: @non_empty_list_top,
     fun: @fun_top
   }
+  @list_top %{bitmap: @bit_empty_list, list: @non_empty_list_top}
   @empty_list %{bitmap: @bit_empty_list}
   @not_non_empty_list Map.delete(@term, :list)
   @not_list Map.replace!(@not_non_empty_list, :bitmap, @bit_top - @bit_empty_list)
@@ -314,6 +315,9 @@ defmodule Module.Types.Descr do
     end
   end
 
+  defp optional_static?(%{optional: 1}), do: true
+  defp optional_static?(%{}), do: false
+
   defp pop_optional_static(:term), do: {false, :term}
 
   defp pop_optional_static(type) do
@@ -2295,7 +2299,6 @@ defmodule Module.Types.Descr do
 
   defp domain_key_to_descr(:atom), do: atom()
   defp domain_key_to_descr(:binary), do: binary()
-  defp domain_key_to_descr(:empty_list), do: empty_list()
   defp domain_key_to_descr(:integer), do: integer()
   defp domain_key_to_descr(:float), do: float()
   defp domain_key_to_descr(:pid), do: pid()
@@ -2304,7 +2307,7 @@ defmodule Module.Types.Descr do
   defp domain_key_to_descr(:fun), do: fun()
   defp domain_key_to_descr(:tuple), do: tuple()
   defp domain_key_to_descr(:map), do: open_map()
-  defp domain_key_to_descr(:list), do: non_empty_list(term(), term())
+  defp domain_key_to_descr(:list), do: @list_top
 
   defp map_descr(tag, pairs, default, force_domains?) do
     {fields, domains, dynamic?} = map_descr_pairs(pairs, [], %{}, false)
@@ -2744,6 +2747,118 @@ defmodule Module.Types.Descr do
     end)
   end
 
+  @doc """
+  Returns the map converted into a list.
+  """
+  def map_to_list(:term), do: :badmap
+
+  def map_to_list(descr) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        if descr_key?(descr, :map) and map_only?(descr) do
+          map_to_list_static(descr.map)
+        else
+          :badmap
+        end
+
+      {dynamic, static} ->
+        if descr_key?(dynamic, :map) and map_only?(static) do
+          with {:ok, dynamic_type} <- map_to_list_static(dynamic.map) do
+            if descr_key?(static, :map) do
+              with {:ok, static_type} <- map_to_list_static(static.map) do
+                {:ok, union(static_type, dynamic(dynamic_type))}
+              end
+            else
+              {:ok, dynamic(dynamic_type)}
+            end
+          end
+        else
+          :badmap
+        end
+    end
+  end
+
+  defp map_to_list_static(bdd) do
+    case map_bdd_to_dnf(bdd) do
+      [] ->
+        :badmap
+
+      dnf ->
+        case map_to_list_static(bdd, dnf) do
+          value when value == @none ->
+            {:ok, empty_list()}
+
+          inner ->
+            if has_empty_map?(dnf) do
+              {:ok, list(inner)}
+            else
+              {:ok, non_empty_list(inner)}
+            end
+        end
+    end
+  end
+
+  defp has_empty_map?(dnf) do
+    Enum.any?(dnf, fn {_, fields, negs} ->
+      Enum.all?(fields, fn {_key, value} -> optional_static?(value) end) and
+        Enum.all?(negs, fn {_, fields} ->
+          not Enum.all?(fields, fn {_key, value} -> optional_static?(value) end)
+        end)
+    end)
+  end
+
+  defp map_to_list_static(bdd, dnf) do
+    try do
+      # Check if any line in the DNF represents an open map or compute the union of domain keys types
+      Enum.reduce(dnf, none(), fn
+        {tag_or_domains, _fields, _negs}, acc ->
+          case tag_or_domains do
+            :open ->
+              # A negation cannot make an open map closed without cancelling it completely,
+              # which is filtered by `map_bdd_to_dnf/1`.
+              throw(:open)
+
+            domains = %{} ->
+              Enum.reduce(domains, acc, fn {domain_key, value}, acc ->
+                value = remove_optional(value)
+
+                if empty?(value) do
+                  acc
+                else
+                  union(acc, tuple([domain_key_to_descr(domain_key), value]))
+                end
+              end)
+
+            _ ->
+              acc
+          end
+      end)
+    catch
+      :open -> tuple([term(), term()])
+    else
+      domain_keys_type ->
+        {_seen, acc} =
+          bdd_reduce(bdd, {%{}, domain_keys_type}, fn {_tag, fields}, seen_acc ->
+            Enum.reduce(fields, seen_acc, fn {key, _type}, {seen, acc} ->
+              if Map.has_key?(seen, key) do
+                {seen, acc}
+              else
+                value = dnf |> map_dnf_fetch_static(key) |> remove_optional_static()
+                seen = Map.put(seen, key, [])
+
+                if empty?(value) do
+                  {seen, acc}
+                else
+                  {seen, union(acc, tuple([atom([key]), value]))}
+                end
+              end
+            end)
+          end)
+
+        acc
+    end
+  end
+
   @doc """
   Updates `key_descr` in `descr` with `type`.
 
@@ -2979,7 +3094,7 @@ defmodule Module.Types.Descr do
           if Map.has_key?(seen, key) do
             {seen, acc}
           else
-            value = dnf |> map_dnf_fetch_static(key) |> remove_optional()
+            value = dnf |> map_dnf_fetch_static(key) |> remove_optional_static()
             {Map.put(seen, key, []), union(acc, value)}
           end
         end)
@@ -3994,8 +4109,8 @@ defmodule Module.Types.Descr do
     here_branch ++ later_branches
   end
 
-  # No more negative elements to process: there is no “all-equal” branch to add,
-  # because we’re constructing {t} ant not {u}, which must differ somewhere.
+  # No more negative elements to process: there is no "all-equal" branch to add,
+  # because we're constructing {t} ant not {u}, which must differ somewhere.
   defp tuple_elim_content(_acc, _tag, _elements, []) do
     []
   end

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

@@ -1509,6 +1509,139 @@ defmodule Module.Types.DescrTest do
              |> equal?(integer())
     end
 
+    test "map_to_list" do
+      assert map_to_list(:term) == :badmap
+      assert map_to_list(integer()) == :badmap
+      assert map_to_list(union(open_map(), integer())) == :badmap
+      assert map_to_list(none()) == :badmap
+
+      # A non existent map type is refused
+      assert open_map()
+             |> difference(open_map(a: if_set(term()), c: if_set(term())))
+             |> map_to_list() == :badmap
+
+      assert map_to_list(empty_map()) == {:ok, empty_list()}
+      assert map_to_list(open_map()) == {:ok, list(tuple([term(), term()]))}
+
+      assert map_to_list(closed_map(a: integer())) ==
+               {:ok, non_empty_list(tuple([atom([:a]), integer()]))}
+
+      assert map_to_list(closed_map(a: integer(), b: atom())) ==
+               {:ok,
+                non_empty_list(
+                  tuple([atom([:a]), integer()])
+                  |> union(tuple([atom([:b]), atom()]))
+                )}
+
+      assert map_to_list(union(closed_map(a: float()), closed_map(b: pid()))) ==
+               {:ok,
+                non_empty_list(
+                  tuple([atom([:a]), float()])
+                  |> union(tuple([atom([:b]), pid()]))
+                )}
+
+      # Test with domain keys
+      assert map_to_list(closed_map([{domain_key(:integer), binary()}])) ==
+               {:ok, list(tuple([integer(), binary()]))}
+
+      assert map_to_list(closed_map([{domain_key(:tuple), binary()}])) ==
+               {:ok, list(tuple([tuple(), binary()]))}
+
+      # Test with both atom keys and domain keys
+      map_with_both =
+        closed_map([
+          {:a, atom([:ok])},
+          {:b, float()},
+          {domain_key(:integer), binary()},
+          {domain_key(:tuple), pid()}
+        ])
+
+      assert map_to_list(map_with_both) ==
+               {:ok,
+                non_empty_list(
+                  tuple([atom([:a]), atom([:ok])])
+                  |> union(tuple([atom([:b]), float()]))
+                  |> union(tuple([integer(), binary()]))
+                  |> union(tuple([tuple(), pid()]))
+                )}
+
+      # Test open maps - should return list of key-value tuples
+      assert map_to_list(open_map()) == {:ok, list(tuple([term(), term()]))}
+      assert map_to_list(open_map(a: integer())) == {:ok, non_empty_list(tuple([term(), term()]))}
+
+      {:ok, list} = map_to_list(open_map([{domain_key(:integer), binary()}]))
+
+      assert list(
+               Enum.reduce(
+                 [binary(), float(), pid(), port(), reference()] ++
+                   [fun(), atom(), tuple(), open_map(), list(term(), term())],
+                 tuple([integer(), binary()]),
+                 fn domain, acc -> union(acc, tuple([domain, term()])) end
+               )
+             )
+             |> equal?(list)
+
+      # Test with multiple domain keys
+      multiple_domains =
+        closed_map([
+          {domain_key(:integer), atom([:int])},
+          {domain_key(:float), atom([:float])},
+          {domain_key(:atom), binary()},
+          {domain_key(:binary), integer()},
+          {domain_key(:tuple), float()}
+        ])
+
+      assert map_to_list(multiple_domains) ==
+               {:ok,
+                list(
+                  tuple([integer(), atom([:int])])
+                  |> union(tuple([float(), atom([:float])]))
+                  |> union(tuple([atom(), binary()]))
+                  |> union(tuple([binary(), integer()]))
+                  |> union(tuple([tuple(), float()]))
+                )}
+
+      # Test dynamic maps
+      assert map_to_list(dynamic(open_map())) ==
+               {:ok, dynamic(list(tuple([term(), term()])))}
+
+      assert map_to_list(dynamic(closed_map(a: integer()))) ==
+               {:ok, dynamic(non_empty_list(tuple([atom([:a]), integer()])))}
+
+      assert map_to_list(union(dynamic(closed_map(a: integer())), closed_map(b: atom()))) ==
+               {:ok,
+                union(
+                  non_empty_list(tuple([atom([:b]), atom()])),
+                  dynamic(
+                    non_empty_list(
+                      union(
+                        tuple([atom([:a]), integer()]),
+                        tuple([atom([:b]), atom()])
+                      )
+                    )
+                  )
+                )}
+
+      # A static integer is refused
+      assert map_to_list(union(dynamic(open_map()), integer())) == :badmap
+
+      # Test with negations
+      assert map_to_list(
+               difference(closed_map(a: integer(), b: atom()), closed_map(a: integer()))
+             ) ==
+               {:ok,
+                non_empty_list(
+                  tuple([atom([:a]), integer()])
+                  |> union(tuple([atom([:b]), atom()]))
+                )}
+
+      # If a key is removed entirely by a negation, it should not appear in the result
+      assert closed_map(a: if_set(integer()), b: atom())
+             |> difference(closed_map(a: integer(), b: term()))
+             |> map_to_list() ==
+               {:ok, non_empty_list(tuple([atom([:b]), atom()]))}
+    end
+
     test "domain_to_args" do
       # take complex tuples, normalize them, and check if they are still equal
       complex_tuples = [
@@ -1803,6 +1936,11 @@ defmodule Module.Types.DescrTest do
       {type, descr, []} = map_update(dynamic(open_map()), atom([:key1, :key2]), integer())
       assert equal?(type, dynamic())
       assert descr == dynamic(union(open_map(key1: integer()), open_map(key2: integer())))
+
+      # A non-existing map
+      assert open_map()
+             |> difference(open_map(a: if_set(term()), c: if_set(term())))
+             |> map_update(atom([:b]), integer()) == {:error, [badkey: :b]}
     end
 
     test "with dynamic atom keys" do
@@ -1889,6 +2027,11 @@ defmodule Module.Types.DescrTest do
       assert map_update(closed_map(key1: binary(), key2: pid()), dynamic(atom()), integer()) ==
                {union(binary(), pid()),
                 closed_map(key1: union(integer(), binary()), key2: union(integer(), pid())), []}
+
+      # A non-existing map
+      assert open_map()
+             |> difference(open_map(a: if_set(term()), c: if_set(term())))
+             |> map_update(binary(), integer()) == {:error, [baddomain: binary()]}
     end
 
     test "with mixed keys" do