More refactor

Author: josevalim

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

@@ -108,8 +108,9 @@ defmodule Module.Types.Expr do
 
   # %{map | ...}
   def of_expr({:%{}, _, [{:|, _, [map, args]}]}, stack, context) do
-    with {:ok, _args_type, context} <- Of.closed_map(args, stack, context, &of_expr/3),
-         {:ok, _map_type, context} <- of_expr(map, stack, context) do
+    {_args_type, context} = Of.closed_map(args, stack, context, &of_expr/3)
+
+    with {:ok, _map_type, context} <- of_expr(map, stack, context) do
       # TODO: intersect map with keys of terms for args
       # TODO: Merge args_type into map_type with dynamic/static key requirement
       {:ok, dynamic(open_map()), context}
@@ -129,28 +130,33 @@ defmodule Module.Types.Expr do
              end
            end),
          # TODO: args_types could be an empty list
-         {:ok, struct_type, context} <-
+         {struct_type, context} =
            Of.struct(module, args_types, :only_defaults, struct_meta, stack, context),
          {: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, error_type(), error(__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)
+        {type, context} =
+          Of.struct(module, args_types, :merge_defaults, struct_meta, stack, context)
+
+        {:ok, type, context}
       end
     end
   end
 
   # %{...}
   def of_expr({:%{}, _meta, args}, stack, context) do
-    Of.closed_map(args, stack, context, &of_expr/3)
+    {type, context} = Of.closed_map(args, stack, context, &of_expr/3)
+    {:ok, type, context}
   end
 
   # %Struct{}
   def of_expr({:%, _, [module, {:%{}, _, args}]} = expr, stack, context) do
     # TODO: We should not skip defaults
-    Of.struct(expr, module, args, :skip_defaults, stack, context, &of_expr/3)
+    {type, context} = Of.struct(expr, module, args, :skip_defaults, stack, context, &of_expr/3)
+    {:ok, type, context}
   end
 
   # ()
@@ -361,7 +367,8 @@ defmodule Module.Types.Expr do
              # Exceptions are not validated in the compiler,
              # to avoid export dependencies. So we do it here.
              if Code.ensure_loaded?(exception) and function_exported?(exception, :__struct__, 0) do
-               Of.struct(exception, args, :merge_defaults, meta, stack, context)
+               {type, context} = Of.struct(exception, args, :merge_defaults, meta, stack, context)
+               {:ok, type, context}
              else
                # If the exception cannot be found or is invalid,
                # we call Of.remote/5 to emit a warning.

lib/elixir/lib/module/types/of.ex

@@ -91,53 +91,59 @@ defmodule Module.Types.Of do
   Builds a closed map.
   """
   def closed_map(pairs, extra \\ [], stack, context, of_fun) do
-    result =
-      reduce_ok(pairs, {true, extra, [], context}, fn
+    of_fun = fn arg1, arg2, arg3 ->
+      case of_fun.(arg1, arg2, arg3) do
+        {:ok, type, context} -> {type, context}
+        {:error, context} -> {dynamic(), context}
+        {type, context} -> {type, context}
+      end
+    end
+
+    {closed?, single, multiple, context} =
+      Enum.reduce(pairs, {true, extra, [], context}, fn
         {key, value}, {closed?, single, multiple, context} ->
-          with {:ok, keys, context} <- of_finite_key_type(key, stack, context, of_fun),
-               {:ok, value_type, context} <- of_fun.(value, stack, context) do
-            case keys do
-              :none ->
-                {:ok, {false, single, multiple, context}}
-
-              [key] when multiple == [] ->
-                {:ok, {closed?, [{key, value_type} | single], multiple, context}}
-
-              keys ->
-                {:ok, {closed?, single, [{keys, value_type} | multiple], context}}
-            end
+          {keys, context} = of_finite_key_type(key, stack, context, of_fun)
+          {value_type, context} = of_fun.(value, stack, context)
+
+          case keys do
+            :none ->
+              {false, single, multiple, context}
+
+            [key] when multiple == [] ->
+              {closed?, [{key, value_type} | single], multiple, context}
+
+            keys ->
+              {closed?, single, [{keys, value_type} | multiple], context}
           end
       end)
 
-    with {:ok, {closed?, single, multiple, context}} <- result do
-      map =
-        case Enum.reverse(multiple) do
-          [] ->
-            pairs = Enum.reverse(single)
-            if closed?, do: closed_map(pairs), else: open_map(pairs)
+    map =
+      case Enum.reverse(multiple) do
+        [] ->
+          pairs = Enum.reverse(single)
+          if closed?, do: closed_map(pairs), else: open_map(pairs)
 
-          [{keys, type} | tail] ->
-            for key <- keys, t <- cartesian_map(tail) do
-              pairs = Enum.reverse(single, [{key, type} | t])
-              if closed?, do: closed_map(pairs), else: open_map(pairs)
-            end
-            |> Enum.reduce(&union/2)
-        end
+        [{keys, type} | tail] ->
+          for key <- keys, t <- cartesian_map(tail) do
+            pairs = Enum.reverse(single, [{key, type} | t])
+            if closed?, do: closed_map(pairs), else: open_map(pairs)
+          end
+          |> Enum.reduce(&union/2)
+      end
 
-      {:ok, map, context}
-    end
+    {map, context}
   end
 
   defp of_finite_key_type(key, _stack, context, _of_fun) when is_atom(key) do
-    {:ok, [key], context}
+    {[key], context}
   end
 
   defp of_finite_key_type(key, stack, context, of_fun) do
-    with {:ok, key_type, context} <- of_fun.(key, stack, context) do
-      case atom_fetch(key_type) do
-        {:finite, list} -> {:ok, list, context}
-        _ -> {:ok, :none, context}
-      end
+    {key_type, context} = of_fun.(key, stack, context)
+
+    case atom_fetch(key_type) do
+      {:finite, list} -> {list, context}
+      _ -> {:none, context}
     end
   end
 
@@ -156,15 +162,22 @@ defmodule Module.Types.Of do
   """
   def struct({:%, meta, _}, struct, args, default_handling, stack, context, of_fun)
       when is_atom(struct) do
-    # The compiler has already checked the keys are atoms and which ones are required.
-    with {:ok, args_types, context} <-
-           map_reduce_ok(args, context, fn {key, value}, context when is_atom(key) ->
-             with {:ok, type, context} <- of_fun.(value, stack, context) do
-               {:ok, {key, type}, context}
-             end
-           end) do
-      struct(struct, args_types, default_handling, meta, stack, context)
+    of_fun = fn arg1, arg2, arg3 ->
+      case of_fun.(arg1, arg2, arg3) do
+        {:ok, type, context} -> {type, context}
+        {:error, context} -> {dynamic(), context}
+        {type, context} -> {type, context}
+      end
     end
+
+    # The compiler has already checked the keys are atoms and which ones are required.
+    {args_types, context} =
+      Enum.map_reduce(args, context, fn {key, value}, context when is_atom(key) ->
+        {type, context} = of_fun.(value, stack, context)
+        {{key, type}, context}
+      end)
+
+    struct(struct, args_types, default_handling, meta, stack, context)
   end
 
   @doc """
@@ -186,7 +199,7 @@ defmodule Module.Types.Of do
         :only_defaults -> [{:__struct__, atom([struct])} | defaults]
       end
 
-    {:ok, dynamic(closed_map(pairs)), context}
+    {dynamic(closed_map(pairs)), context}
   end
 
   @doc """

lib/elixir/lib/module/types/pattern.ex

@@ -624,12 +624,14 @@ defmodule Module.Types.Pattern do
   def of_guard({:%, _, [module, {:%{}, _, args}]} = struct, _expected, _expr, stack, context)
       when is_atom(module) do
     fun = &of_guard(&1, dynamic(), struct, &2, &3)
-    Of.struct(struct, module, args, :skip_defaults, stack, context, fun)
+    {type, context} = Of.struct(struct, module, args, :skip_defaults, stack, context, fun)
+    {:ok, type, context}
   end
 
   # %{...}
   def of_guard({:%{}, _meta, args}, _expected, expr, stack, context) do
-    Of.closed_map(args, stack, context, &of_guard(&1, dynamic(), expr, &2, &3))
+    {type, context} = Of.closed_map(args, stack, context, &of_guard(&1, dynamic(), expr, &2, &3))
+    {:ok, type, context}
   end
 
   # <<>>