Add guards and introduce error_type() for clarity

Author: josevalim

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

@@ -733,7 +733,7 @@ defmodule Module.Types.Descr do
   """
   def map_fetch(:term, _key), do: :badmap
 
-  def map_fetch(%{} = descr, key) do
+  def map_fetch(%{} = descr, key) when is_atom(key) do
     case :maps.take(:dynamic, descr) do
       :error ->
         if descr_key?(descr, :map) and map_only?(descr) do
@@ -792,9 +792,9 @@ defmodule Module.Types.Descr do
   a map (or dynamic).
   """
   def map_put(:term, _key, _type), do: :badmap
-  def map_put(descr, key, :term), do: map_put_static_value(descr, key, :term)
+  def map_put(descr, key, :term) when is_atom(key), do: map_put_static_value(descr, key, :term)
 
-  def map_put(descr, key, type) do
+  def map_put(descr, key, type) when is_atom(key) do
     case :maps.take(:dynamic, type) do
       :error -> map_put_static_value(descr, key, type)
       {dynamic, _static} -> dynamic(map_put_static_value(descr, key, dynamic))
@@ -981,7 +981,7 @@ defmodule Module.Types.Descr do
   """
   def map_delete(:term, _key), do: :badmap
 
-  def map_delete(descr, key) do
+  def map_delete(descr, key) when is_atom(key) do
     case :maps.take(:dynamic, descr) do
       :error ->
         # Note: the empty typ is not a valid input

lib/elixir/lib/module/types/expr.ex

@@ -156,7 +156,7 @@ defmodule Module.Types.Expr do
          {:ok, map_type, context} <- of_expr(map, stack, context) do
       if disjoint?(struct_type, map_type) do
         warning = {:badupdate, :struct, expr, struct_type, map_type, context}
-        {:ok, dynamic(), warn(__MODULE__, warning, update_meta, stack, context)}
+        {:ok, error_type(), warn(__MODULE__, warning, update_meta, stack, context)}
       else
         # TODO: Merge args_type into map_type with dynamic/static key requirement
         Of.struct(module, args_types, :merge_defaults, struct_meta, stack, context)
@@ -384,12 +384,10 @@ defmodule Module.Types.Expr do
              if Code.ensure_loaded?(exception) and function_exported?(exception, :__struct__, 0) do
                Of.struct(exception, args, :merge_defaults, meta, stack, context)
              else
-               # Whenever there is a failure (such as undefined function),
-               # we return dynamic to avoid cascading errors. In this case,
-               # we can return something a bit more precise than dynamic,
-               # but we still want an open map to avoid cascading.
+               # If the exception cannot be found or is invalid,
+               # we call Of.remote/5 to emit a warning.
                context = Of.remote(exception, :__struct__, 0, meta, stack, context)
-               {:ok, dynamic(open_map([__struct__: atom([exception])] ++ args)), context}
+               {:ok, error_type(), context}
              end
            end) do
       context =
@@ -480,6 +478,8 @@ defmodule Module.Types.Expr do
 
   ## General helpers
 
+  defp error_type(), do: dynamic()
+
   defp apply_many([], _function, _args_types, _expr, _stack, context) do
     {:ok, dynamic(), context}
   end