Properly preserve function dynamic type on application

Author: josevalim

CHANGELOG.md

@@ -52,7 +52,7 @@ It is also possible to mix domain keys, as above, with atom keys, yielding the f
 %{integer() => integer(), root: integer()}
 ```
 
-This system is an implementation of [Polymorphic Records for Dynamic Languages, by Giuseppe Castagna and Loïc Peyrot (2024)](https://arxiv.org/abs/2404.00338).
+This system is an implementation of [Typing Records, Maps, and Structs, by Giuseppe Castagna (2023)](https://www.irif.fr/~gc/papers/icfp23.pdf).
 
 ### Typing of map operations
 

lib/elixir/lib/module/types/apply.ex

@@ -365,14 +365,14 @@ defmodule Module.Types.Apply do
     {{:strong, nil, [{domain, open_map()}]}, domain, context}
   end
 
-  def remote_domain(Map, :pop!, [_, key], expected, _meta, _stack, context) when is_atom(key) do
-    domain = [open_map([{key, expected}]), term()]
-    {{:strong, nil, [{domain, open_map()}]}, domain, context}
+  def remote_domain(Map, :pop!, [_, key], _expected, _meta, _stack, context) when is_atom(key) do
+    domain = [open_map([{key, term()}]), term()]
+    {{:strong, nil, [{domain, tuple([term(), open_map()])}]}, domain, context}
   end
 
-  def remote_domain(Map, :update!, [_, key, _], expected, _meta, _stack, context)
+  def remote_domain(Map, :update!, [_, key, _], _expected, _meta, _stack, context)
       when is_atom(key) do
-    domain = [open_map([{key, expected}]), term(), fun(1)]
+    domain = [open_map([{key, term()}]), term(), fun(1)]
     {{:strong, nil, [{domain, open_map()}]}, domain, context}
   end
 
@@ -540,10 +540,10 @@ defmodule Module.Types.Apply do
           _ -> {map, default}
         end
 
-      {map, fun} =
+      map =
         case fun do
-          %{dynamic: fun} -> {dynamic(map), fun}
-          _ -> {map, fun}
+          %{dynamic: _} -> dynamic(map)
+          _ -> map
         end
 
       fun_apply = fn optional?, arg_type ->
@@ -1059,10 +1059,10 @@ defmodule Module.Types.Apply do
 
   def map_update_or_replace_lazy(name, [map, key, fun] = args_types, stack, error) do
     try do
-      {map, fun} =
+      map =
         case fun do
-          %{dynamic: fun} -> {dynamic(map), fun}
-          _ -> {map, fun}
+          %{dynamic: _} -> dynamic(map)
+          _ -> map
         end
 
       fun_apply = fn optional?, arg_type ->

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

@@ -1357,6 +1357,11 @@ defmodule Module.Types.MapTest do
                    (:bar -> dynamic(:value))
                """
     end
+
+    test "with unknown function type" do
+      assert typecheck!([x], Map.update!(x, :body, &:zlib.gunzip/1)) ==
+               dynamic(open_map(body: term()))
+    end
   end
 
   describe "Map.values/1" do