Simplify precision tracking in bitstrings

Author: josevalim

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

@@ -549,47 +549,30 @@ defmodule Module.Types.Of do
   In the stack, we add nodes such as <<expr>>, <<..., expr>>, etc,
   based on the position of the expression within the binary.
   """
-  def bitstring(args, kind, stack, context) do
-    {type, nil, context} =
-      bitstring(args, kind, stack, context, nil, fn _segment, nil, context ->
-        {nil, context}
-      end)
-
-    {type, context}
-  end
-
-  def bitstring(args, kind, stack, context, acc, fun) when is_function(fun, 3) do
-    do_bitstring(args, kind, stack, context, acc, fun)
-  end
-
-  defp do_bitstring([], _kind, _stack, context, acc, _fun) do
-    {binary(), acc, context}
+  def bitstring([], _kind, _stack, context) do
+    {binary(), context}
   end
 
-  defp do_bitstring([head], kind, stack, context, acc, fun) do
-    {alignment, acc, context} = bitstring_segment(head, kind, [head], stack, context, acc, fun)
-    {alignment_to_type(alignment), acc, context}
+  def bitstring([head], kind, stack, context) do
+    {alignment, context} = bitstring_segment(head, kind, [head], stack, context)
+    {alignment_to_type(alignment), context}
   end
 
-  defp do_bitstring([head | tail], kind, stack, context, acc, fun) do
-    {alignment, acc, context} =
-      bitstring_segment(head, kind, [head, @suffix], stack, context, acc, fun)
-
-    bitstring_tail(tail, alignment, kind, stack, context, acc, fun)
+  def bitstring([head | tail], kind, stack, context) do
+    {alignment, context} = bitstring_segment(head, kind, [head, @suffix], stack, context)
+    bitstring_tail(tail, alignment, kind, stack, context)
   end
 
-  defp bitstring_tail([last], alignment, kind, stack, context, acc, fun) do
-    {seg_alignment, acc, context} =
-      bitstring_segment(last, kind, [@prefix, last], stack, context, acc, fun)
-
-    {alignment_to_type(alignment(seg_alignment, alignment)), acc, context}
+  defp bitstring_tail([last], alignment, kind, stack, context) do
+    {seg_alignment, context} = bitstring_segment(last, kind, [@prefix, last], stack, context)
+    {alignment_to_type(alignment(seg_alignment, alignment)), context}
   end
 
-  defp bitstring_tail([head | tail], alignment, kind, stack, context, acc, fun) do
-    {seg_alignment, acc, context} =
-      bitstring_segment(head, kind, [@prefix, head, @suffix], stack, context, acc, fun)
+  defp bitstring_tail([head | tail], alignment, kind, stack, context) do
+    {seg_alignment, context} =
+      bitstring_segment(head, kind, [@prefix, head, @suffix], stack, context)
 
-    bitstring_tail(tail, alignment(seg_alignment, alignment), kind, stack, context, acc, fun)
+    bitstring_tail(tail, alignment(seg_alignment, alignment), kind, stack, context)
   end
 
   defp alignment(left, right) when is_integer(left) and is_integer(right), do: left + right
@@ -599,15 +582,9 @@ defmodule Module.Types.Of do
   defp alignment_to_type(integer) when rem(integer, 8) == 0, do: binary()
   defp alignment_to_type(_integer), do: bitstring_no_binary()
 
-  defp bitstring_segment(segment, kind, args, stack, context, acc, fun) do
-    {acc, context} = fun.(segment, acc, context)
-    {alignment, context} = do_bitstring_segment(segment, kind, args, stack, context)
-    {alignment, acc, context}
-  end
-
   # If the segment is a literal, the compiler has already checked its validity,
   # so we just check the size.
-  defp do_bitstring_segment({:"::", _meta, [left, right]}, kind, _args, stack, context)
+  defp bitstring_segment({:"::", _meta, [left, right]}, kind, _args, stack, context)
        when is_binary(left) or is_number(left) do
     {_type, alignment_type} = specifier_type(kind, right)
     {alignment_value, context} = specifier_size(kind, right, stack, {:default, context})
@@ -622,7 +599,7 @@ defmodule Module.Types.Of do
     end
   end
 
-  defp do_bitstring_segment({:"::", meta, [left, right]}, kind, args, stack, context) do
+  defp bitstring_segment({:"::", meta, [left, right]}, kind, args, stack, context) do
     {type, alignment_type} = specifier_type(kind, right)
     expr = {:<<>>, meta, args}
 

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

@@ -786,12 +786,9 @@ defmodule Module.Types.Pattern do
 
   # <<...>>>
   defp of_pattern({:<<>>, _meta, args} = node, _path, stack, context) do
-    {type, reused?, context} =
-      Of.bitstring(args, :match, stack, context, false, fn segment, reused?, context ->
-        {reused? or reused_bitstring_segment?(segment, context.vars), context}
-      end)
-
-    {type, of_precise_bitstring?(node) and not reused?, context}
+    precise? = of_precise_bitstring?(node, context.vars)
+    {type, context} = Of.bitstring(args, :match, stack, context)
+    {type, precise?, context}
   end
 
   # left ++ right
@@ -991,33 +988,19 @@ defmodule Module.Types.Pattern do
     {type, precise?, put_in(context.subpatterns[key], of_pattern_tree(type, stack, context))}
   end
 
-  defp reused_bitstring_segment?({:"::", _, [expr, _type]}, vars) do
-    reused_bitstring_expr?(expr, vars)
+  defp of_precise_bitstring?({:<<>>, _meta, [{:"::", _, [expr, {type, _, _}]}]}, vars)
+       when type in [:binary, :bitstring, :bytes, :bits] do
+    new_var?(expr, vars) or of_precise_bitstring?(expr, vars)
   end
 
-  defp reused_bitstring_segment?(_segment, _vars) do
-    false
-  end
+  defp of_precise_bitstring?(_expr, _vars), do: false
 
-  defp reused_bitstring_expr?({_, meta, _} = var, vars) when is_var(var) do
+  defp new_var?({_, meta, _} = var, vars) when is_var(var) do
     version = Keyword.fetch!(meta, :version)
-    is_map_key(vars, version)
-  end
-
-  defp reused_bitstring_expr?({:<<>>, _, args}, vars) do
-    Enum.any?(args, &reused_bitstring_segment?(&1, vars))
-  end
-
-  defp reused_bitstring_expr?(_expr, _vars) do
-    false
-  end
-
-  defp of_precise_bitstring?({:<<>>, _meta, [{:"::", _, [expr, {type, _, _}]}]})
-       when type in [:binary, :bitstring, :bytes, :bits] do
-    is_var(expr) or of_precise_bitstring?(expr)
+    not is_map_key(vars, version)
   end
 
-  defp of_precise_bitstring?(_), do: false
+  defp new_var?(_expr, _vars), do: false
 
   ## Guards
   #

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

@@ -1380,6 +1380,10 @@ defmodule Module.Types.PatternTest do
       refute precise?([x, <<x>>])
       refute precise?([x, <<y, x>>])
       refute precise?([x, <<(<<x::binary>>)::binary>>])
+      refute precise?([<<x::binary>>, x])
+      refute precise?([<<x>>, x])
+      refute precise?([<<y, x>>, x])
+      refute precise?([<<(<<x::binary>>)::binary>>, x])
     end
 
     test "tuples in patterns" do