Track reused variables in bitstring patterns

Author: josevalim

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

@@ -549,30 +549,47 @@ 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([], _kind, _stack, context) do
-    {binary(), context}
+  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}
   end
 
-  def bitstring([head], kind, stack, context) do
-    {alignment, context} = bitstring_segment(head, kind, [head], stack, context)
-    {alignment_to_type(alignment), context}
+  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}
   end
 
-  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)
+  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)
   end
 
-  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}
+  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}
   end
 
-  defp bitstring_tail([head | tail], alignment, kind, stack, context) do
-    {seg_alignment, context} =
-      bitstring_segment(head, kind, [@prefix, head, @suffix], stack, context)
+  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)
 
-    bitstring_tail(tail, alignment(seg_alignment, alignment), kind, stack, context)
+    bitstring_tail(tail, alignment(seg_alignment, alignment), kind, stack, context, acc, fun)
   end
 
   defp alignment(left, right) when is_integer(left) and is_integer(right), do: left + right
@@ -582,9 +599,15 @@ 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 bitstring_segment({:"::", _meta, [left, right]}, kind, _args, stack, context)
+  defp do_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})
@@ -599,7 +622,7 @@ defmodule Module.Types.Of do
     end
   end
 
-  defp bitstring_segment({:"::", meta, [left, right]}, kind, args, stack, context) do
+  defp do_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,8 +786,12 @@ defmodule Module.Types.Pattern do
 
   # <<...>>>
   defp of_pattern({:<<>>, _meta, args} = node, _path, stack, context) do
-    {type, context} = Of.bitstring(args, :match, stack, context)
-    {type, of_precise_bitstring?(node), context}
+    {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}
   end
 
   # left ++ right
@@ -987,6 +991,27 @@ 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)
+  end
+
+  defp reused_bitstring_segment?(_segment, _vars) do
+    false
+  end
+
+  defp reused_bitstring_expr?({_, 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)

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

@@ -1376,6 +1376,10 @@ defmodule Module.Types.PatternTest do
       refute precise?([<<_::binary-size(8)>>])
       refute precise?([<<_::bitstring-size(8)>>])
       refute precise?([<<(<<123>>)::bits>>])
+      refute precise?([x, <<x::binary>>])
+      refute precise?([x, <<x>>])
+      refute precise?([x, <<y, x>>])
+      refute precise?([x, <<(<<x::binary>>)::binary>>])
     end
 
     test "tuples in patterns" do