Unify :empty_list and :list domains in maps

Author: gldubc

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

@@ -28,20 +28,8 @@ defmodule Module.Types.Descr do
 
   defmacro bdd_leaf(arg1, arg2), do: {arg1, arg2}
 
-  @domain_key_types [
-    :binary,
-    :empty_list,
-    :integer,
-    :float,
-    :pid,
-    :port,
-    :reference,
-    :fun,
-    :atom,
-    :tuple,
-    :map,
-    :list
-  ]
+  @domain_key_types [:binary, :integer, :float, :pid, :port, :reference] ++
+                      [:fun, :atom, :tuple, :map, :list]
 
   # Remark: those are explicit BDD constructors. The functional constructors are `bdd_new/1` and `bdd_new/3`.
   @fun_top {:negation, %{}}
@@ -2274,17 +2262,28 @@ defmodule Module.Types.Descr do
     for {type_kind, type} <- key_descr, reduce: [] do
       acc ->
         cond do
-          type_kind == :atom and match?({:union, _}, type) -> acc
-          type_kind == :bitmap -> bitmap_to_domain_keys(type, acc)
-          not empty?(%{type_kind => type}) -> [type_kind | acc]
-          true -> acc
+          type_kind == :list and
+              match?(%{bitmap: bitmap} when (bitmap &&& @bit_empty_list) != 0, key_descr) ->
+            acc
+
+          type_kind == :atom and match?({:union, _}, type) ->
+            acc
+
+          type_kind == :bitmap ->
+            bitmap_to_domain_keys(type, acc)
+
+          not empty?(%{type_kind => type}) ->
+            [type_kind | acc]
+
+          true ->
+            acc
         end
     end
   end
 
   defp bitmap_to_domain_keys(bitmap, acc) do
     acc = if (bitmap &&& @bit_binary) != 0, do: [:binary | acc], else: acc
-    acc = if (bitmap &&& @bit_empty_list) != 0, do: [:empty_list | acc], else: acc
+    acc = if (bitmap &&& @bit_empty_list) != 0, do: [:list | acc], else: acc
     acc = if (bitmap &&& @bit_integer) != 0, do: [:integer | acc], else: acc
     acc = if (bitmap &&& @bit_float) != 0, do: [:float | acc], else: acc
     acc = if (bitmap &&& @bit_pid) != 0, do: [:pid | acc], else: acc

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

@@ -1723,6 +1723,33 @@ defmodule Module.Types.DescrTest do
                {:ok, union(atom([:b]), pid() |> nil_or_type())}
     end
 
+    test "map_get with lists" do
+      # Verify that empty_list() bitmap type maps to :list domain (not :empty_list domain)
+      map_with_list_domain = closed_map([{domain_key(:list), atom([:empty])}])
+
+      # empty_list() should access the :list domain
+      assert map_get(map_with_list_domain, empty_list()) == {:ok, atom([:empty]) |> nil_or_type()}
+
+      # non_empty_list() should also access the :list domain
+      assert map_get(map_with_list_domain, non_empty_list(integer())) ==
+               {:ok, atom([:empty]) |> nil_or_type()}
+
+      # list() should also access the :list domain
+      assert map_get(map_with_list_domain, list(integer())) ==
+               {:ok, atom([:empty]) |> nil_or_type()}
+
+      # If I create a map and instantiate both empty_list() and non_empty_list(integer()), it should return the union of the two types
+      map =
+        closed_map([{domain_key(:list), atom([:empty])}, {domain_key(:list), atom([:non_empty])}])
+
+      assert map_get(map, empty_list()) == {:ok, atom([:empty, :non_empty]) |> nil_or_type()}
+
+      assert map_get(map, non_empty_list(integer())) ==
+               {:ok, atom([:empty, :non_empty]) |> nil_or_type()}
+
+      assert map_get(map, list(integer())) == {:ok, atom([:empty, :non_empty]) |> nil_or_type()}
+    end
+
     test "map_update" do
       assert map_update(open_map(key: atom([:value])), atom([:key]), atom([:new_value])) ==
                {:ok, open_map(key: atom([:new_value]))}