More tests around descr map_fetch

Author: josevalim

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

@@ -620,9 +620,13 @@ defmodule Module.Types.Descr do
     case :maps.take(:dynamic, descr) do
       :error ->
         if is_map_key(descr, :map) and map_only?(descr) do
-          map_fetch_static(descr, key)
-          |> none_if_not_set()
-          |> badkey_if_empty_or_tag(false)
+          {static_optional?, static_type} = map_fetch_static(descr, key) |> pop_optional()
+
+          if static_optional? or empty?(static_type) do
+            :badkey
+          else
+            {false, static_type}
+          end
         else
           :badmap
         end
@@ -631,11 +635,15 @@ defmodule Module.Types.Descr do
         {true, dynamic()}
 
       {dynamic, static} ->
-        if (is_map_key(dynamic, :map) or is_map_key(static, :map)) and map_only?(static) do
-          {optional?, dynamic_type} = map_fetch_static(dynamic, key) |> pop_not_set()
+        if is_map_key(dynamic, :map) and map_only?(static) do
+          {dynamic_optional?, dynamic_type} = map_fetch_static(dynamic, key) |> pop_optional()
+          {static_optional?, static_type} = map_fetch_static(static, key) |> pop_optional()
 
-          dynamic(dynamic_type)
-          |> badkey_if_empty_or_tag(optional?)
+          if static_optional? or empty?(dynamic_type) do
+            :badkey
+          else
+            {dynamic_optional?, union(dynamic(dynamic_type), static_type)}
+          end
         else
           :badmap
         end
@@ -651,11 +659,7 @@ defmodule Module.Types.Descr do
     end
   end
 
-  defp badkey_if_empty_or_tag(type, tag) do
-    if empty?(type), do: :badkey, else: {tag, type}
-  end
-
-  defp pop_not_set(type) do
+  defp pop_optional(type) do
     case type do
       %{bitmap: @bit_optional} ->
         {true, Map.delete(type, :bitmap)}
@@ -668,13 +672,6 @@ defmodule Module.Types.Descr do
     end
   end
 
-  defp none_if_not_set(type) do
-    case type do
-      %{bitmap: bitmap} when (bitmap &&& @bit_optional) != 0 -> @none
-      _ -> type
-    end
-  end
-
   # Union is list concatenation
   defp map_union(dnf1, dnf2), do: dnf1 ++ dnf2
 

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

@@ -259,30 +259,26 @@ defmodule Module.Types.DescrTest do
     end
 
     test "map_fetch" do
-      assert map_fetch(closed_map(a: integer()), :a) == {false, integer()}
-
       assert map_fetch(term(), :a) == :badmap
       assert map_fetch(union(open_map(), integer()), :a) == :badmap
-      assert map_fetch(dynamic(), :a) == {true, dynamic()}
 
-      assert intersection(dynamic(), open_map(a: integer()))
-             |> map_fetch(:a) == {false, intersection(integer(), dynamic())}
+      assert map_fetch(closed_map(a: integer()), :a) == {false, integer()}
 
-      {false, value_type} =
-        open_map(my_map: open_map(foo: integer()))
-        |> intersection(open_map(my_map: open_map(bar: boolean())))
-        |> map_fetch(:my_map)
+      assert map_fetch(union(closed_map(a: integer()), closed_map(b: atom())), :a) ==
+               :badkey
 
-      assert equal?(value_type, open_map(foo: integer(), bar: boolean()))
+      assert map_fetch(difference(closed_map(a: integer()), closed_map(a: term())), :a) ==
+               :badkey
 
       assert map_fetch(union(closed_map(a: integer()), closed_map(a: atom())), :a) ==
                {false, union(integer(), atom())}
 
-      assert map_fetch(union(closed_map(a: integer()), closed_map(b: atom())), :a) ==
-               :badkey
+      {false, value_type} =
+        open_map(my_map: open_map(foo: integer()))
+        |> intersection(open_map(my_map: open_map(bar: boolean())))
+        |> map_fetch(:my_map)
 
-      assert map_fetch(difference(closed_map(a: integer()), closed_map(a: term())), :a) ==
-               :badkey
+      assert equal?(value_type, open_map(foo: integer(), bar: boolean()))
 
       {false, value_type} =
         closed_map(a: union(integer(), atom()))
@@ -335,6 +331,21 @@ defmodule Module.Types.DescrTest do
              |> difference(open_map(a: atom([:foo, :baz])))
              |> map_fetch(:a) == {false, integer()}
     end
+
+    test "map_fetch with dynamic" do
+      assert map_fetch(dynamic(), :a) == {true, dynamic()}
+
+      assert intersection(dynamic(), open_map(a: integer()))
+             |> map_fetch(:a) == {false, intersection(integer(), dynamic())}
+
+      {false, type} = union(dynamic(integer()), open_map(a: integer())) |> map_fetch(:a)
+      assert equal?(type, integer())
+
+      assert union(dynamic(integer()), open_map(a: if_set(integer()))) |> map_fetch(:a) == :badkey
+
+      assert union(dynamic(open_map(a: atom())), open_map(a: integer()))
+             |> map_fetch(:a) == {false, union(dynamic(atom()), integer())}
+    end
   end
 
   describe "to_quoted" do