Move of_head to Pattern

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -8,12 +8,14 @@ defmodule Module.Types do
   Infer function definitions' types.
   """
   def infer_definitions(file, module, defs, no_warn_undefined, cache) do
+    stack = stack()
+
     Enum.flat_map(defs, fn {{fun, _arity} = function, kind, meta, clauses} ->
       context = context(with_file_meta(meta, file), module, function, no_warn_undefined, cache)
 
-      Enum.flat_map(clauses, fn {_meta, params, guards, body} ->
-        def_expr = {kind, meta, [guards_to_expr(guards, {fun, [], params})]}
-        infer_clause(params, guards, body, def_expr, context)
+      Enum.flat_map(clauses, fn {_meta, args, guards, body} ->
+        def_expr = {kind, meta, [guards_to_expr(guards, {fun, [], args})]}
+        infer_definition(args, guards, body, def_expr, stack, context)
       end)
     end)
   end
@@ -25,33 +27,18 @@ defmodule Module.Types do
     end
   end
 
-  @doc false
-  def infer_clause(params, guards, body, def_expr, context) do
-    with {:ok, _types, context} <- of_head(params, guards, def_expr, context),
-         {:ok, _type, context} <- of_body(body, context) do
+  defp infer_definition(args, guards, body, def_expr, stack, context) do
+    head_stack = push_expr_stack(def_expr, stack)
+
+    with {:ok, _types, context} <- Pattern.of_head(args, guards, head_stack, context),
+         {:ok, _type, context} <- Expr.of_expr(body, stack, context) do
       context.warnings
     else
       {:error, {type, error, context}} ->
         [error_to_warning(type, error, context) | context.warnings]
     end
   end
 
-  @doc false
-  def of_head(params, guards, def_expr, context) do
-    stack = push_expr_stack(def_expr, stack())
-
-    with {:ok, types, context} <-
-           map_reduce_ok(params, context, &Pattern.of_pattern(&1, stack, &2)),
-         # TODO: Check that of_guard/3 returns boolean() | :fail
-         {:ok, _, context} <- Pattern.of_guard(guards_to_or(guards), stack, context),
-         do: {:ok, types, context}
-  end
-
-  @doc false
-  def of_body(body, context) do
-    Expr.of_expr(body, stack(), context)
-  end
-
   @doc false
   def context(file, module, function, no_warn_undefined, cache) do
     %{

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

@@ -469,10 +469,7 @@ defmodule Module.Types.Expr do
     each_ok(clauses, fn {:->, _meta, [head, body]} ->
       {patterns, guards} = extract_head(head)
 
-      with {:ok, _pattern_types, context} <-
-             map_reduce_ok(patterns, context, &Pattern.of_pattern(&1, stack, &2)),
-           # TODO: Check that of_guard/3 returns a boolean
-           {:ok, _guard_type, context} <- Pattern.of_guard(guards_to_or(guards), stack, context),
+      with {:ok, _, context} <- Pattern.of_head(patterns, guards, stack, context),
            {:ok, _expr_type, _context} <- of_expr(body, stack, context),
            do: :ok
     end)

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

@@ -4,6 +4,17 @@ defmodule Module.Types.Pattern do
   alias Module.Types.Remote
   import Module.Types.{Helpers, Infer}
 
+  @doc """
+  Handles patterns and guards at once.
+  """
+  def of_head(patterns, guards, stack, context) do
+    with {:ok, types, context} <-
+           map_reduce_ok(patterns, context, &of_pattern(&1, stack, &2)),
+         # TODO: Check that of_guard/3 returns boolean() | :fail
+         {:ok, _, context} <- of_guard(guards_to_or(guards), stack, context),
+         do: {:ok, types, context}
+  end
+
   @doc """
   Return the type and typing context of a pattern expression or an error
   in case of a typing conflict.

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

@@ -3,14 +3,15 @@ Code.require_file("../../test_helper.exs", __DIR__)
 defmodule Module.Types.PatternTest do
   use ExUnit.Case, async: true
   import Module.Types.Infer, only: [new_var: 2]
-  import Module.Types.Pattern
+
   alias Module.Types
+  alias Module.Types.Pattern
 
   defmacrop quoted_pattern(patterns) do
     quote do
       {patterns, true} = unquote(Macro.escape(expand_head(patterns, true)))
 
-      of_pattern(patterns, new_stack(), new_context())
+      Pattern.of_pattern(patterns, new_stack(), new_context())
       |> lift_result()
     end
   end
@@ -20,7 +21,7 @@ defmodule Module.Types.PatternTest do
       {vars, guards} = unquote(Macro.escape(expand_head(vars, guards)))
       context = Enum.reduce(vars, new_context(), &(new_var(&1, &2) |> elem(1)))
 
-      of_guard(guards, new_stack(), context)
+      Pattern.of_guard(guards, new_stack(), context)
     end
   end
 
@@ -242,16 +243,18 @@ end
 defmodule Module.Types.TempTypesTest do
   use ExUnit.Case, async: true
   import Bitwise, warn: false
+
   alias Module.Types
+  alias Module.Types.{Expr, Pattern}
 
   defmacrop quoted_head(patterns, guards \\ [true]) do
     quote do
       {patterns, guards} = unquote(Macro.escape(expand_head(patterns, guards)))
 
-      Types.of_head(
+      Pattern.of_head(
         patterns,
         guards,
-        def_expr(),
+        new_stack(),
         new_context()
       )
       |> lift_result()
@@ -262,8 +265,8 @@ defmodule Module.Types.TempTypesTest do
     quote do
       {patterns, guards, body} = unquote(Macro.escape(expand_expr(patterns, guards, body)))
 
-      with {:ok, _types, context} <- Types.of_head(patterns, guards, def_expr(), new_context()),
-           {:ok, type, context} <- Types.of_body(body, context) do
+      with {:ok, _types, context} <- Pattern.of_head(patterns, guards, new_stack(), new_context()),
+           {:ok, type, context} <- Expr.of_expr(body, new_stack(), context) do
         {:ok, Types.lift_type(type, context)}
       else
         {:error, {type, reason, _context}} ->
@@ -304,8 +307,11 @@ defmodule Module.Types.TempTypesTest do
     Types.context("types_test.ex", TypesTest, {:test, 0}, [], Module.ParallelChecker.test_cache())
   end
 
-  defp def_expr() do
-    {:def, [], {:test, [], []}}
+  defp new_stack() do
+    %{
+      Types.stack()
+      | last_expr: {:foo, [], nil}
+    }
   end
 
   defp lift_result({:ok, types, context}) when is_list(types) do
@@ -323,18 +329,18 @@ defmodule Module.Types.TempTypesTest do
       assert quoted_head([a, a]) == {:ok, [{:var, 0}, {:var, 0}]}
 
       assert {:ok, [{:var, 0}, {:var, 0}], _} =
-               Types.of_head(
+               Pattern.of_head(
                  [{:a, [version: 0], :foo}, {:a, [version: 0], :foo}],
                  [],
-                 def_expr(),
+                 new_stack(),
                  new_context()
                )
 
       assert {:ok, [{:var, 0}, {:var, 1}], _} =
-               Types.of_head(
+               Pattern.of_head(
                  [{:a, [version: 0], :foo}, {:a, [version: 1], :foo}],
                  [],
-                 def_expr(),
+                 new_stack(),
                  new_context()
                )
     end