Move traversal to a separate module for clarity and simplicity

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -24,14 +24,11 @@ defmodule Module.Types do
   #
   #   * :infer - Same as :dynamic but skips remote calls.
   #
-  #   * :traversal - Focused mostly on traversing AST, skips most type system
-  #     operations. Used by macros and when skipping inference.
-  #
   # The mode may also control exhaustiveness checks in the future (to be decided).
   # We may also want for applications with subtyping in dynamic mode to always
   # intersect with dynamic, but this mode may be too lax (to be decided based on
   # feedback).
-  @modes [:static, :dynamic, :infer, :traversal]
+  @modes [:static, :dynamic, :infer]
 
   # These functions are not inferred because they are added/managed by the compiler
   @no_infer [behaviour_info: 1]
@@ -125,7 +122,7 @@ defmodule Module.Types do
   end
 
   defp infer_mode(kind, infer_signatures?) do
-    if infer_signatures? and kind in [:def, :defp], do: :infer, else: :traversal
+    if infer_signatures? and kind in [:def, :defp], do: :infer, else: :traverse
   end
 
   defp protocol?(attrs) do
@@ -154,7 +151,7 @@ defmodule Module.Types do
         | List.duplicate(Descr.dynamic(), arity - 1)
       ]
 
-      {fun_arity, kind, meta, clauses} = def
+      {_fun_arity, kind, meta, clauses} = def
 
       clauses =
         for {meta, args, guards, body} <- clauses do
@@ -291,7 +288,7 @@ defmodule Module.Types do
             context = put_in(context.local_sigs, Map.put(local_sigs, fun_arity, kind))
 
             {inferred, mapping, context} =
-              local_handler(fun_arity, kind, meta, clauses, expected, mode, stack, context)
+              local_handler(mode, fun_arity, kind, meta, clauses, expected, stack, context)
 
             context =
               update_in(context.local_sigs, &Map.put(&1, fun_arity, {kind, inferred, mapping}))
@@ -304,7 +301,17 @@ defmodule Module.Types do
     end
   end
 
-  defp local_handler(fun_arity, kind, meta, clauses, expected, mode, stack, context) do
+  defp local_handler(:traverse, {_, arity}, _kind, _meta, clauses, _expected, stack, context) do
+    context =
+      Enum.reduce(clauses, context, fn {_meta, _args, _guards, body}, context ->
+        Module.Types.Traverse.of_expr(body, stack, context)
+      end)
+
+    inferred = {:infer, nil, [{List.duplicate(Descr.term(), arity), Descr.dynamic()}]}
+    {inferred, [{0, 0}], context}
+  end
+
+  defp local_handler(mode, fun_arity, kind, meta, clauses, expected, stack, context) do
     {fun, _arity} = fun_arity
     stack = stack |> fresh_stack(mode, fun_arity) |> with_file_meta(meta)
 
@@ -320,12 +327,7 @@ defmodule Module.Types do
             {return_type, context} =
               Expr.of_expr(body, Descr.term(), body, stack, context)
 
-            args_types =
-              if stack.mode == :traversal do
-                expected
-              else
-                Pattern.of_domain(trees, context)
-              end
+            args_types = Pattern.of_domain(trees, context)
 
             {type_index, inferred} =
               add_inferred(inferred, args_types, return_type, total - 1, [])

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

@@ -320,10 +320,6 @@ defmodule Module.Types.Apply do
 
   Used only by info functions.
   """
-  def remote_domain(_fun, args, _expected, %{mode: :traversal}) do
-    {:none, Enum.map(args, fn _ -> term() end)}
-  end
-
   def remote_domain(fun, args, expected, _stack) do
     arity = length(args)
     info = signature(fun, arity)
@@ -333,10 +329,6 @@ defmodule Module.Types.Apply do
   @doc """
   Returns the domain of a remote function with info to apply it.
   """
-  def remote_domain(_module, _fun, args, _expected, _meta, %{mode: :traversal}, context) do
-    {:none, Enum.map(args, fn _ -> term() end), context}
-  end
-
   def remote_domain(:erlang, :is_function, [_, arity], expected, _meta, _stack, context)
       when is_integer(arity) and arity >= 0 do
     type = fun(arity)
@@ -834,14 +826,11 @@ defmodule Module.Types.Apply do
   Returns the type of a remote capture.
   """
   def remote_capture(modules, fun, arity, meta, stack, context) do
-    cond do
-      stack.mode == :traversal ->
-        {dynamic(), context}
-
-      modules == [] ->
+    case modules do
+      [] ->
         {dynamic(fun(arity)), context}
 
-      true ->
+      [_ | _] ->
         {type, fallback?, context} =
           Enum.reduce(modules, {none(), false, context}, fn module, {type, fallback?, context} ->
             case signature(module, fun, arity, meta, stack, context) do
@@ -898,7 +887,7 @@ defmodule Module.Types.Apply do
 
   defp export(module, fun, arity, meta, %{cache: cache} = stack, context) do
     cond do
-      cache == nil or stack.mode == :traversal ->
+      cache == nil ->
         {:none, context}
 
       stack.mode == :infer ->
@@ -1003,7 +992,7 @@ defmodule Module.Types.Apply do
       {kind, info, context} ->
         update_used? = is_warning(stack) and kind == :defp
 
-        if stack.mode == :traversal or info == :none do
+        if info == :none do
           {{update_used?, :none}, List.duplicate(term(), arity), context}
         else
           {{update_used?, info}, filter_domain(info, expected, arity), context}
@@ -1060,9 +1049,6 @@ defmodule Module.Types.Apply do
       false ->
         {dynamic(fun(arity)), context}
 
-      {_kind, _info, context} when stack.mode == :traversal ->
-        {dynamic(fun(arity)), context}
-
       {kind, info, context} ->
         result =
           case info do

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

@@ -87,34 +87,28 @@ defmodule Module.Types.Expr do
   def of_expr(list, expected, expr, stack, context) when is_list(list) do
     {prefix, suffix} = unpack_list(list, [])
 
-    if stack.mode == :traversal do
-      {_, context} = Enum.map_reduce(prefix, context, &of_expr(&1, term(), expr, stack, &2))
-      {_, context} = of_expr(suffix, term(), expr, stack, context)
-      {dynamic(), context}
-    else
-      hd_type =
-        case list_hd(expected) do
-          {:ok, type} -> type
-          _ -> term()
-        end
+    hd_type =
+      case list_hd(expected) do
+        {:ok, type} -> type
+        _ -> term()
+      end
 
-      {prefix, context} = Enum.map_reduce(prefix, context, &of_expr(&1, hd_type, expr, stack, &2))
+    {prefix, context} = Enum.map_reduce(prefix, context, &of_expr(&1, hd_type, expr, stack, &2))
 
-      {suffix, context} =
-        if suffix == [] do
-          {empty_list(), context}
-        else
-          tl_type =
-            case list_tl(expected) do
-              {:ok, type} -> type
-              :badnonemptylist -> term()
-            end
+    {suffix, context} =
+      if suffix == [] do
+        {empty_list(), context}
+      else
+        tl_type =
+          case list_tl(expected) do
+            {:ok, type} -> type
+            :badnonemptylist -> term()
+          end
 
-          of_expr(suffix, tl_type, expr, stack, context)
-        end
+        of_expr(suffix, tl_type, expr, stack, context)
+      end
 
-      {non_empty_list(Enum.reduce(prefix, &union/2), suffix), context}
-    end
+    {non_empty_list(Enum.reduce(prefix, &union/2), suffix), context}
   end
 
   # {left, right}
@@ -178,23 +172,17 @@ defmodule Module.Types.Expr do
         {{key_type, value_type}, context}
       end)
 
-    expected =
-      if stack.mode == :traversal do
-        expected
-      else
-        # The only information we can attach to the expected types is that
-        # certain keys are expected.
-        expected_pairs =
-          Enum.flat_map(pairs_types, fn {key_type, _value_type} ->
-            case atom_fetch(key_type) do
-              {:finite, [key]} -> [{key, term()}]
-              _ -> []
-            end
-          end)
-
-        intersection(expected, open_map(expected_pairs))
-      end
+    # The only information we can attach to the expected types is that
+    # certain keys are expected.
+    expected_pairs =
+      Enum.flat_map(pairs_types, fn {key_type, _value_type} ->
+        case atom_fetch(key_type) do
+          {:finite, [key]} -> [{key, term()}]
+          _ -> []
+        end
+      end)
 
+    expected = intersection(expected, open_map(expected_pairs))
     {map_type, context} = of_expr(map, expected, expr, stack, context)
 
     try do
@@ -226,16 +214,12 @@ defmodule Module.Types.Expr do
     {map_type, context} = of_expr(map, term(), struct, stack, context)
 
     context =
-      if stack.mode == :traversal do
+      with {false, struct_key_type} <- map_fetch_key(map_type, :__struct__),
+           {:finite, [^module]} <- atom_fetch(struct_key_type) do
         context
       else
-        with {false, struct_key_type} <- map_fetch_key(map_type, :__struct__),
-             {:finite, [^module]} <- atom_fetch(struct_key_type) do
-          context
-        else
-          _ ->
-            error(__MODULE__, {:badupdate, map_type, struct, context}, meta, stack, context)
-        end
+        _ ->
+          error(__MODULE__, {:badupdate, map_type, struct, context}, meta, stack, context)
       end
 
     Enum.reduce(pairs, {map_type, context}, fn {key, value}, {acc, context} ->
@@ -337,19 +321,14 @@ defmodule Module.Types.Expr do
     {patterns, _guards} = extract_head(head)
     domain = Enum.map(patterns, fn _ -> dynamic() end)
 
-    if stack.mode == :traversal do
-      {_acc, context} = of_clauses(clauses, domain, @pending, nil, :fn, stack, context, none())
-      {dynamic(), context}
-    else
-      {acc, context} =
-        of_clauses_fun(clauses, domain, @pending, nil, :fn, stack, context, [], fn
-          trees, body, context, acc ->
-            args = Pattern.of_domain(trees, context)
-            add_inferred(acc, args, body)
-        end)
-
-      {fun_from_inferred_clauses(acc), context}
-    end
+    {acc, context} =
+      of_clauses_fun(clauses, domain, @pending, nil, :fn, stack, context, [], fn
+        trees, body, context, acc ->
+          args = Pattern.of_domain(trees, context)
+          add_inferred(acc, args, body)
+      end)
+
+    {fun_from_inferred_clauses(acc), context}
   end
 
   def of_expr({:try, _meta, [[do: body] ++ blocks]}, expected, expr, stack, original) do
@@ -469,11 +448,7 @@ defmodule Module.Types.Expr do
     {args_types, context} =
       Enum.map_reduce(args, context, &of_expr(&1, @pending, &1, stack, &2))
 
-    if stack.mode == :traversal do
-      {dynamic(), context}
-    else
-      Apply.fun_apply(fun_type, args_types, call, stack, context)
-    end
+    Apply.fun_apply(fun_type, args_types, call, stack, context)
   end
 
   def of_expr({{:., _, [callee, key_or_fun]}, meta, []} = call, expected, expr, stack, context)
@@ -528,19 +503,13 @@ defmodule Module.Types.Expr do
   # var
   def of_expr(var, expected, expr, stack, context) when is_var(var) do
     case stack do
-      %{mode: :traversal} -> {dynamic(), context}
       %{refine_vars: false} -> {Of.var(var, context), context}
       %{} -> Of.refine_body_var(var, expected, expr, stack, context)
     end
   end
 
   ## Tuples
 
-  defp of_tuple(elems, _expected, expr, %{mode: :traversal} = stack, context) do
-    {_types, context} = Enum.map_reduce(elems, context, &of_expr(&1, term(), expr, stack, &2))
-    {dynamic(), context}
-  end
-
   defp of_tuple(elems, expected, expr, stack, context) do
     of_tuple(elems, 0, [], expected, expr, stack, context)
   end
@@ -741,14 +710,8 @@ defmodule Module.Types.Expr do
   defp dynamic_unless_static({_, _} = output, %{mode: :static}), do: output
   defp dynamic_unless_static({type, context}, %{mode: _}), do: {dynamic(type), context}
 
-  defp of_clauses(clauses, domain, expected, expr, info, %{mode: mode} = stack, context, acc) do
-    fun =
-      if mode == :traversal do
-        fn _, _, _, _ -> dynamic() end
-      else
-        fn _trees, result, _context, acc -> union(result, acc) end
-      end
-
+  defp of_clauses(clauses, domain, expected, expr, info, stack, context, acc) do
+    fun = fn _trees, result, _context, acc -> union(result, acc) end
     of_clauses_fun(clauses, domain, expected, expr, info, stack, context, acc, fun)
   end
 

lib/elixir/lib/module/types/helpers.ex

@@ -11,7 +11,7 @@ defmodule Module.Types.Helpers do
   @doc """
   Returns true if the mode cares about warnings.
   """
-  defguard is_warning(stack) when stack.mode not in [:traversal, :infer]
+  defguard is_warning(stack) when stack.mode != :infer
 
   @doc """
   Guard function to check if an AST node is a variable.

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

@@ -196,17 +196,6 @@ defmodule Module.Types.Of do
   @doc """
   Builds a closed map.
   """
-  def closed_map(pairs, _expected, %{mode: :traversal} = stack, context, of_fun) do
-    context =
-      Enum.reduce(pairs, context, fn {key, value}, context ->
-        {_key_type, context} = of_fun.(key, term(), stack, context)
-        {_, context} = of_fun.(value, term(), stack, context)
-        context
-      end)
-
-    {dynamic(), context}
-  end
-
   def closed_map(pairs, expected, stack, context, of_fun) do
     {pairs_types, context} = pairs(pairs, expected, stack, context, of_fun)
 
@@ -354,18 +343,16 @@ defmodule Module.Types.Of do
   Handles instantiation of a new struct.
   """
   # TODO: Type check the fields match the struct
-  def struct_instance(struct, args, expected, meta, %{mode: mode} = stack, context, of_fun)
+  def struct_instance(struct, args, expected, meta, stack, context, of_fun)
       when is_atom(struct) do
     {_info, context} = struct_info(struct, meta, stack, context)
 
     # 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) ->
         value_type =
-          with true <- mode != :traversal,
-               {_, expected_value_type} <- map_fetch_key(expected, key) do
-            expected_value_type
-          else
+          case map_fetch_key(expected, key) do
+            {_, expected_value_type} -> expected_value_type
             _ -> term()
           end