Ensure we can escape bitstrings, add Macro.validate/1

Author: José Valim

lib/elixir/lib/macro.ex

@@ -305,6 +305,40 @@ defmodule Macro do
     elem(:elixir_quote.escape(expr, Keyword.get(opts, :unquote, false)), 0)
   end
 
+  @doc """
+  Validates the given expressions are valid quoted expressions.
+
+  Check the `type:Macro.t` for the specification of a valid
+  quoted expression.
+  """
+  @spec validate(term) :: :ok | {:error, term}
+  def validate(expr) do
+    find_invalid(expr) || :ok
+  end
+
+  defp find_invalid({left, right}), do:
+    find_invalid(left) || find_invalid(right)
+
+  defp find_invalid({left, meta, right}) when is_list(meta) and (is_atom(right) or is_list(right)), do:
+    find_invalid(left) || find_invalid(right)
+
+  defp find_invalid(list) when is_list(list), do:
+    Enum.find_value(list, &find_invalid/1)
+
+  defp find_invalid(pid)  when is_pid(pid),    do: nil
+  defp find_invalid(atom) when is_atom(atom),  do: nil
+  defp find_invalid(num)  when is_number(num), do: nil
+  defp find_invalid(bin)  when is_binary(bin), do: nil
+
+  defp find_invalid(fun) when is_function(fun) do
+    unless :erlang.fun_info(fun, :env) == {:env, []} and
+           :erlang.fun_info(fun, :type) == {:type, :external} do
+      {:error, fun}
+    end
+  end
+
+  defp find_invalid(other), do: {:error, other}
+
   @doc ~S"""
   Unescape the given chars.
 

lib/elixir/src/elixir_exp.erl

@@ -354,7 +354,7 @@ expand({_, Meta, Args} = Invalid, E) when is_list(Meta) and is_list(Args) ->
 
 expand({_, _, _} = Tuple, E) ->
   compile_error([{line,0}], ?m(E, file), "invalid quoted expression: ~ts",
-    ['Elixir.Kernel':inspect(Tuple, [{records,false}])]);
+    ['Elixir.Kernel':inspect(Tuple, [])]);
 
 %% Literals
 

lib/elixir/src/elixir_quote.erl

@@ -242,6 +242,15 @@ do_quote({Left, Right}, Q, E) ->
   {TRight, RQ} = do_quote(Right, LQ, E),
   {{TLeft, TRight}, RQ};
 
+do_quote(BitString, #elixir_quote{escape=true} = Q, E) when is_bitstring(BitString) ->
+  case bit_size(BitString) rem 8 of
+    0 ->
+      {BitString, Q};
+    Size ->
+      <<Bits:Size, Bytes/binary>> = BitString,
+      {{'<<>>', [], [{'::', [], [Bits, Size]}, Bytes]}, Q}
+  end;
+
 do_quote(Map, #elixir_quote{escape=true} = Q, E) when is_map(Map) ->
   {TT, TQ} = do_quote(maps:to_list(Map), Q, E),
   {{'%{}', [], TT}, TQ};
@@ -259,6 +268,7 @@ do_quote(List, #elixir_quote{escape=true} = Q, E) when is_list(List) ->
       {TR, QR} = do_quote(R, QL, E),
       {update_last(TL, fun(X) -> {'|', [], [X, TR]} end), QR}
   end;
+
 do_quote(List, Q, E) when is_list(List) ->
     do_splice(lists:reverse(List), Q, E);
 

lib/elixir/test/elixir/kernel_test.exs

@@ -89,6 +89,12 @@ defmodule KernelTest do
     assert case_in(-3, -1..-3) == true
   end
 
+  @bitstring <<"foo", 16::4>>
+
+  test "bitstring attribute" do
+    assert @bitstring == <<"foo", 16::4>>
+  end
+
   test "paren as nil" do
     assert nil?(()) == true
     assert ((); ();) == nil

lib/elixir/test/elixir/macro_test.exs

@@ -42,6 +42,10 @@ defmodule MacroTest do
     assert {:%{}, [], [a: 1]} = Macro.escape(%{a: 1})
   end
 
+  test :escape_handles_bitstring do
+    assert {:<<>>, [], [{:::, [], [1, 4]}, ","]} == Macro.escape(<<300::12>>)
+  end
+
   test :escape_works_recursively do
     assert [1,{:{}, [], [:a,:b,:c]}, 3] == Macro.escape([1, {:a, :b, :c}, 3])
   end
@@ -445,6 +449,30 @@ defmodule MacroTest do
            "::Bar:.foo(:1:, :2:, :3:):"
   end
 
+  ## validate
+
+  test :validate do
+    ref = make_ref()
+
+    assert Macro.validate(1) == :ok
+    assert Macro.validate(1.0) == :ok
+    assert Macro.validate(:foo) == :ok
+    assert Macro.validate("bar") == :ok
+    assert Macro.validate(self()) == :ok
+    assert Macro.validate({1, 2}) == :ok
+    assert Macro.validate({:foo, [], :baz}) == :ok
+    assert Macro.validate({:foo, [], []}) == :ok
+    assert Macro.validate([1, 2, 3]) == :ok
+
+    assert Macro.validate(<<0::4>>) == {:error, <<0::4>>}
+    assert Macro.validate(ref) == {:error, ref}
+    assert Macro.validate({1, ref}) == {:error, ref}
+    assert Macro.validate({ref, 2}) == {:error, ref}
+    assert Macro.validate([1, ref, 3]) == {:error, ref}
+    assert Macro.validate({:foo, [], 0}) == {:error, {:foo, [], 0}}
+    assert Macro.validate({:foo, 0, []}) == {:error, {:foo, 0, []}}
+  end
+
   ## decompose_call
 
   test :decompose_call do