Compute alignment

Author: josevalim

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

@@ -174,7 +174,7 @@ defmodule Module.Types.Apply do
         {:erlang, :bsl, [{[integer(), integer()], integer()}]},
         {:erlang, :bsr, [{[integer(), integer()], integer()}]},
         {:erlang, :bxor, [{[integer(), integer()], integer()}]},
-        {:erlang, :byte_size, [{[binary()], integer()}]},
+        {:erlang, :byte_size, [{[bitstring()], integer()}]},
         {:erlang, :ceil, [{[union(integer(), float())], integer()}]},
         {:erlang, :div, [{[integer(), integer()], integer()}]},
         {:erlang, :error, [{[term()], none()}]},

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

@@ -122,8 +122,8 @@ defmodule Module.Types.Expr do
   end
 
   # <<...>>>
-  def of_expr({:<<>>, _meta, args}, _expected, _expr, stack, context) do
-    Of.bitstring(args, :expr, stack, context)
+  def of_expr({:<<>>, meta, args}, _expected, _expr, stack, context) do
+    Of.bitstring(meta, args, :expr, stack, context)
   end
 
   def of_expr({:__CALLER__, _meta, var_context}, _expected, _expr, _stack, context)

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

@@ -476,27 +476,36 @@ 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.
   """
-  # TODO: Return binary, bitstring or bitstring_no_binary
-  def bitstring([], _kind, _stack, context) do
-    {binary(), context}
+  def bitstring(meta, parts, kind, stack, context) do
+    context = bitstring(parts, kind, stack, context)
+
+    case Keyword.get(meta, :alignment, :unknown) do
+      :unknown -> {bitstring(), context}
+      0 -> {binary(), context}
+      _ -> {bitstring_no_binary(), context}
+    end
+  end
+
+  defp bitstring([], _kind, _stack, context) do
+    context
   end
 
-  def bitstring([head], kind, stack, context) do
-    {binary(), bitstring_segment(head, kind, [head], stack, context)}
+  defp bitstring([head], kind, stack, context) do
+    bitstring_segment(head, kind, [head], stack, context)
   end
 
-  def bitstring([head | tail], kind, stack, context) do
+  defp bitstring([head | tail], kind, stack, context) do
     context = bitstring_segment(head, kind, [head, @suffix], stack, context)
-    {binary(), bitstring_many(tail, kind, stack, context)}
+    bitstring_tail(tail, kind, stack, context)
   end
 
-  defp bitstring_many([last], kind, stack, context) do
+  defp bitstring_tail([last], kind, stack, context) do
     bitstring_segment(last, kind, [@prefix, last], stack, context)
   end
 
-  defp bitstring_many([head | tail], kind, stack, context) do
+  defp bitstring_tail([head | tail], kind, stack, context) do
     context = bitstring_segment(head, kind, [@prefix, head, @suffix], stack, context)
-    bitstring_many(tail, kind, stack, context)
+    bitstring_tail(tail, kind, stack, context)
   end
 
   # If the segment is a literal, the compiler has already checked its validity,

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

@@ -401,8 +401,8 @@ defmodule Module.Types.Pattern do
     end
   end
 
-  def of_match_var({:<<>>, _meta, args}, _expected, _expr, stack, context) do
-    Of.bitstring(args, :match, stack, context)
+  def of_match_var({:<<>>, meta, args}, _expected, _expr, stack, context) do
+    Of.bitstring(meta, args, :match, stack, context)
   end
 
   def of_match_var({:^, _meta, [{_, meta, _}]}, expected, expr, stack, context) do
@@ -592,8 +592,8 @@ defmodule Module.Types.Pattern do
   end
 
   # <<...>>>
-  defp of_pattern({:<<>>, _meta, args}, _path, stack, context) do
-    Of.bitstring(args, :match, stack, context)
+  defp of_pattern({:<<>>, meta, args}, _path, stack, context) do
+    Of.bitstring(meta, args, :match, stack, context)
   end
 
   # left ++ right
@@ -851,8 +851,8 @@ defmodule Module.Types.Pattern do
   end
 
   # <<>>
-  def of_guard({:<<>>, _meta, args}, _expected, _expr, stack, context) do
-    Of.bitstring(args, :guard, stack, context)
+  def of_guard({:<<>>, meta, args}, _expected, _expr, stack, context) do
+    Of.bitstring(meta, args, :guard, stack, context)
   end
 
   # ^var

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

@@ -31,6 +31,15 @@ defmodule Module.Types.ExprTest do
     assert typecheck!([x = 1], generated(x)) == dynamic()
   end
 
+  describe "bitstrings" do
+    test "alignment" do
+      assert typecheck!(<<round(:rand.uniform())>>) == binary()
+      assert typecheck!(<<round(:rand.uniform())::1>>) == difference(bitstring(), binary())
+      assert typecheck!(<<round(:rand.uniform())::4, round(:rand.uniform())::4>>) == binary()
+      assert typecheck!([size], <<round(:rand.uniform())::size(size)>>) == bitstring()
+    end
+  end
+
   describe "lists" do
     test "creating lists" do
       assert typecheck!([1, 2]) == non_empty_list(integer())
@@ -678,7 +687,7 @@ defmodule Module.Types.ExprTest do
     end
 
     test "size ok" do
-      assert typecheck!([<<x, y>>, z], <<z::size(x - y)>>) == binary()
+      assert typecheck!([<<x, y>>, z], <<z::size(x - y)>>) == bitstring()
     end
 
     test "size error" do

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

@@ -328,7 +328,14 @@ defmodule Module.Types.PatternTest do
     end
   end
 
-  describe "binaries" do
+  describe "bitstrings" do
+    test "alignment" do
+      assert typecheck!([<<_>> = x], x) == dynamic(binary())
+      assert typecheck!([<<_::1>> = x], x) == dynamic(difference(bitstring(), binary()))
+      assert typecheck!([<<_::4, _::4>> = x], x) == dynamic(binary())
+      assert typecheck!([<<size, _::size(size)>> = x], x) == dynamic(bitstring())
+    end
+
     test "ok" do
       assert typecheck!([<<x>>], x) == integer()
       assert typecheck!([<<x::float>>], x) == float()
@@ -337,7 +344,27 @@ defmodule Module.Types.PatternTest do
     end
 
     test "nested" do
-      assert typecheck!([<<0, <<x::bitstring>>::binary>>], x) == binary()
+      assert typecheck!([<<0, <<x::binary>>::binary>>], x) == binary()
+
+      assert typeerror!([<<0, <<x::bitstring>>::binary>>], x) == ~l"""
+             incompatible types in binary matching:
+
+                 <<..., <<x::bitstring>>::binary>>
+
+             got type:
+
+                 bitstring()
+
+             but expected type:
+
+                 binary()
+
+             where "x" was given the type:
+
+                 # type: bitstring()
+                 # from: types_test.ex:LINE
+                 <<x::bitstring>>
+             """
     end
 
     test "error" do