Allow <<_::3*8>> in typespecs

Author: josevalim

lib/elixir/lib/code/typespec.ex

@@ -283,7 +283,6 @@ defmodule Code.Typespec do
   end
 
   defp typespec_to_quoted({:type, anno, :binary, [arg1, arg2]}) do
-    [arg1, arg2] = for arg <- [arg1, arg2], do: typespec_to_quoted(arg)
     line = meta(anno)[:line]
 
     case {typespec_to_quoted(arg1), typespec_to_quoted(arg2)} do
@@ -329,10 +328,14 @@ defmodule Code.Typespec do
     {erl_to_ex_var(var), meta(anno), nil}
   end
 
-  defp typespec_to_quoted({:op, anno, op, arg}) do
+  defp typespec_to_quoted({:op, anno, op, arg}) when op in [:+, :-] do
     {op, meta(anno), [typespec_to_quoted(arg)]}
   end
 
+  defp typespec_to_quoted({:op, anno, :*, arg1, arg2}) do
+    {:*, meta(anno), [typespec_to_quoted(arg1), typespec_to_quoted(arg2)]}
+  end
+
   defp typespec_to_quoted({:remote_type, anno, [mod, name, args]}) do
     remote_type(anno, mod, name, args)
   end

lib/elixir/lib/kernel/typespec.ex

@@ -493,6 +493,24 @@ defmodule Kernel.Typespec do
      state}
   end
 
+  defp typespec(
+         {:<<>>, meta, [{:"::", _, [{:_, _, ctx1}, {:*, prod_meta, [size, unit]}]}]},
+         _,
+         _,
+         state
+       )
+       when is_atom(ctx1) and is_integer(size) and size >= 0 and unit in 1..256 do
+    location = location(meta)
+    prod_location = location(prod_meta)
+
+    {{:type, location, :binary,
+      [
+        {:op, prod_location, :*, {:integer, prod_location, size},
+         {:integer, prod_location, unit}},
+        {:integer, location, 0}
+      ]}, state}
+  end
+
   defp typespec({:<<>>, meta, [{:"::", size_meta, [{:_, _, ctx}, size]}]}, _, _, state)
        when is_atom(ctx) and is_integer(size) and size >= 0 do
     location = location(meta)

lib/elixir/test/elixir/typespec_test.exs

@@ -393,6 +393,7 @@ defmodule TypespecTest do
           @type size :: <<_::3>>
           @type unit :: <<_::_*8>>
           @type size_and_unit :: <<_::3, _::_*8>>
+          @type size_prod_unit :: <<_::3*8>>
         end
 
       assert [
@@ -401,17 +402,15 @@ defmodule TypespecTest do
                type: {:size, {:type, _, :binary, [{:integer, _, 3}, {:integer, _, 0}]}, []},
                type:
                  {:size_and_unit, {:type, _, :binary, [{:integer, _, 3}, {:integer, _, 8}]}, []},
+               type:
+                 {:size_prod_unit,
+                  {:type, _, :binary,
+                   [{:op, _, :*, {:integer, _, 3}, {:integer, _, 8}}, {:integer, _, 0}]}, []},
                type: {:unit, {:type, _, :binary, [{:integer, _, 0}, {:integer, _, 8}]}, []}
              ] = types(bytecode)
     end
 
     test "@type with invalid binary spec" do
-      assert_raise Kernel.TypespecError, ~r"invalid binary specification", fn ->
-        test_module do
-          @type my_type :: <<_::3*8>>
-        end
-      end
-
       assert_raise Kernel.TypespecError, ~r"invalid binary specification", fn ->
         test_module do
           @type my_type :: <<_::atom()>>
@@ -1217,6 +1216,7 @@ defmodule TypespecTest do
           quote(do: @type(binary_type1() :: <<_::_*8>>)),
           quote(do: @type(binary_type2() :: <<_::3>>)),
           quote(do: @type(binary_type3() :: <<_::3, _::_*8>>)),
+          quote(do: @type(binary_type4() :: <<_::3*8>>)),
           quote(do: @type(tuple_type() :: {integer()})),
           quote(do: @type(ftype() :: (-> any()) | (-> integer()) | (integer() -> integer()))),
           quote(do: @type(cl() :: charlist())),