Refactor refine_body_var for guards

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -452,7 +452,7 @@ defmodule Module.Types do
       subpatterns: %{},
       # Variables that are specific to the current environment/conditional
       conditional_vars: nil,
-      # Track metadata specific to matches and guards
+      # Track metadata specific to patterns and guards
       pattern_info: nil,
       # If type checking has found an error/failure
       failed: false,

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

@@ -86,13 +86,14 @@ defmodule Module.Types.Of do
   or if we are doing a guard analysis or occurrence typing.
   Returns `true` if there was a refinement, `false` otherwise.
   """
-  def refine_body_var(var_or_version, type, expr, stack, context, allow_empty? \\ false)
+  @skip_refinement_for [term(), dynamic()]
+  def refine_body_var(var_or_version, type, expr, stack, context)
 
-  def refine_body_var({_, meta, _}, type, expr, stack, context, allow_empty?) do
-    refine_body_var(Keyword.fetch!(meta, :version), type, expr, stack, context, allow_empty?)
+  def refine_body_var({_, meta, _}, type, expr, stack, context) do
+    refine_body_var(Keyword.fetch!(meta, :version), type, expr, stack, context)
   end
 
-  def refine_body_var(version, type, expr, stack, context, allow_empty?)
+  def refine_body_var(version, type, expr, stack, context)
       when is_integer(version) or is_reference(version) do
     %{vars: %{^version => %{type: old_type, off_traces: off_traces} = data} = vars} = context
 
@@ -105,12 +106,15 @@ defmodule Module.Types.Of do
           context
       end
 
-    if match?(%{pattern_info: %{allow_empty?: _}}, context) do
-      if type not in [term(), dynamic()] and not is_map_key(data, :errored) do
+    case context do
+      _ when type in @skip_refinement_for or is_map_key(data, :errored) ->
+        {old_type, context}
+
+      %{pattern_info: %{guard_context: guard_context}} ->
         new_type = intersection(old_type, type)
 
         case empty?(new_type) do
-          true when allow_empty? ->
+          true when guard_context == :orelse ->
             data = %{
               data
               | type: none(),
@@ -131,21 +135,9 @@ defmodule Module.Types.Of do
           _ ->
             {old_type, context}
         end
-      else
-        {old_type, context}
-      end
-    else
-      if gradual?(old_type) and type not in [term(), dynamic()] and not is_map_key(data, :errored) do
-        case compatible_intersection(old_type, type) do
-          {:error, _} when allow_empty? ->
-            data = %{
-              data
-              | type: none(),
-                off_traces: new_trace(expr, none(), stack, off_traces)
-            }
-
-            {none(), %{context | vars: %{vars | version => data}}}
 
+      _ ->
+        case gradual?(old_type) and compatible_intersection(old_type, type) do
           {:ok, new_type} when new_type != old_type ->
             data = %{
               data
@@ -158,9 +150,6 @@ defmodule Module.Types.Of do
           _ ->
             {old_type, context}
         end
-      else
-        {old_type, context}
-      end
     end
   end
 

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

@@ -1026,7 +1026,7 @@ defmodule Module.Types.Pattern do
   defp of_guards(guards, vars, stack, context) do
     context =
       init_pattern_info(context, %{
-        allow_empty?: false,
+        guard_context: :andalso,
         parent_version: nil,
         vars: vars,
         changed: %{}
@@ -1066,7 +1066,7 @@ defmodule Module.Types.Pattern do
   end
 
   defp enable_conditional_mode(%{pattern_info: pattern_info} = context) do
-    %{context | pattern_info: %{pattern_info | allow_empty?: true}, conditional_vars: %{}}
+    %{context | pattern_info: %{pattern_info | guard_context: :orelse}, conditional_vars: %{}}
   end
 
   defp maybe_badguard(type, guard, stack, context) do
@@ -1184,8 +1184,7 @@ defmodule Module.Types.Pattern do
     # and also when vars change, so we need to deal with all possibilities
     # for pattern_info.
     case context.pattern_info do
-      %{allow_empty?: allow_empty?, vars: vars, parent_version: parent_version, changed: changed} =
-          pattern_info ->
+      %{vars: vars, parent_version: parent_version, changed: changed} = pattern_info ->
         vars =
           is_map(vars) and not is_map_key(vars, version) and
             not list_subpattern?(version, context) and vars
@@ -1199,7 +1198,7 @@ defmodule Module.Types.Pattern do
             do: Of.track_var(version, [parent_version], [], context),
             else: context
 
-        Of.refine_body_var(version, expected, expr, stack, context, allow_empty?)
+        Of.refine_body_var(version, expected, expr, stack, context)
 
       list when is_list(list) ->
         node = path_node(expected, var, expr, [])