Adopt EEP 54

With EEP 54 (part of Erlang/OTP 24+), we can now get extra
information from Erlang errors. Before this patch:

    Interactive Elixir (1.12.0-dev)
    iex(1)> ets = :ets.new(:example, [])
    #Reference<0.3845811859.2669281281.223553>
    iex(2)> :ets.delete(ets)
    true
    iex(3)> :ets.insert(ets, :should_be_a_tuple)
    ** (ArgumentError) argument error
        (stdlib 3.15) :ets.insert(#Reference<0.3845811859.2669281281.223553>, :should_be_a_tuple)

After this patch:

    Interactive Elixir (1.12.0-dev)
    iex(1)> ets = :ets.new(:example, [])
    #Reference<0.105641012.1058144260.76455>
    iex(2)> :ets.delete(ets)
    true
    iex(3)> :ets.insert(ets, :should_be_a_tuple)
    ** (ArgumentError) errors were found at the given arguments:

      * 1st argument: the table identifier does not refer to an existing ETS table
      * 2nd argument: not a tuple

        (stdlib 3.15) :ets.insert(#Reference<0.105641012.1058144260.76455>, :should_be_a_tuple)

We choose to always track error info, instead of moving this
to blame, because it should be relatively cheap and it is
essential, especially when debugging live systems.

Author: josevalim

lib/elixir/lib/exception.ex

@@ -709,7 +709,7 @@ defmodule ArgumentError do
 
   @impl true
   def blame(
-        %{message: "argument error"} = exception,
+        exception,
         [{:erlang, :apply, [module, function, args], _} | _] = stacktrace
       ) do
     message =
@@ -783,12 +783,7 @@ defmodule ArithmeticError do
 end
 
 defmodule SystemLimitError do
-  defexception []
-
-  @impl true
-  def message(_) do
-    "a system limit has been reached"
-  end
+  defexception message: "a system limit has been reached"
 end
 
 defmodule SyntaxError do
@@ -1417,16 +1412,32 @@ defmodule ErlangError do
   end
 
   @doc false
-  def normalize(:badarg, _stacktrace) do
-    %ArgumentError{}
+  def normalize(:badarg, stacktrace) do
+    case error_info(:badarg, stacktrace) do
+      {:ok, args} ->
+        message = "errors were found at the given arguments:\n\n#{args}"
+        %ArgumentError{message: message}
+
+      :error ->
+        %ArgumentError{}
+    end
   end
 
   def normalize(:badarith, _stacktrace) do
     %ArithmeticError{}
   end
 
-  def normalize(:system_limit, _stacktrace) do
-    %SystemLimitError{}
+  def normalize(:system_limit, stacktrace) do
+    case error_info(:system_limit, stacktrace) do
+      {:ok, args} ->
+        message =
+          "a system limit has been reached due to errors at the given arguments:\n\n#{args}"
+
+        %SystemLimitError{message: message}
+
+      :error ->
+        %SystemLimitError{}
+    end
   end
 
   def normalize(:cond_clause, _stacktrace) do
@@ -1516,4 +1527,31 @@ defmodule ErlangError do
   defp from_stacktrace(_) do
     {nil, nil, nil}
   end
+
+  @doc false
+  def error_info(erl_exception, stacktrace) do
+    with [{module, _, args_or_arity, opts} | _] <- stacktrace,
+         %{} = error_info <- opts[:error_info] do
+      module = Map.get(error_info, :module, module)
+      function = Map.get(error_info, :function, :format_error)
+      arity = if is_integer(args_or_arity), do: args_or_arity, else: length(args_or_arity)
+      extra = apply(module, function, [erl_exception, stacktrace])
+      args_errors = Map.take(extra, Enum.to_list(1..arity//1))
+
+      if map_size(args_errors) > 0 do
+        {:ok, IO.iodata_to_binary(Enum.map(args_errors, &arg_error/1))}
+      else
+        :error
+      end
+    else
+      _ -> :error
+    end
+  end
+
+  defp arg_error({n, message}), do: "  * #{nth(n)} argument: #{message}\n"
+
+  defp nth(1), do: "1st"
+  defp nth(2), do: "2nd"
+  defp nth(3), do: "3rd"
+  defp nth(n), do: "#{n}th"
 end

lib/elixir/lib/io.ex

@@ -108,8 +108,8 @@ defmodule IO do
   argument error. For example, let's try to put a code point that is not
   representable with one byte, like `?π`, inside IO data:
 
-      iex> IO.iodata_to_binary(["The symbol for pi is: ", ?π])
-      ** (ArgumentError) argument error
+      IO.iodata_to_binary(["The symbol for pi is: ", ?π])
+      #=> ** (ArgumentError) argument error
 
   If we use chardata instead, it will work as expected:
 

lib/elixir/lib/kernel.ex

@@ -535,12 +535,14 @@ defmodule Kernel do
       hd([1, 2, 3, 4])
       #=> 1
 
-      hd([])
-      ** (ArgumentError) argument error
-
       hd([1 | 2])
       #=> 1
 
+  Giving it an empty list raises:
+
+      tl([])
+      #=> ** (ArgumentError) argument error
+
   """
   @doc guard: true
   @spec hd(nonempty_maybe_improper_list(elem, any)) :: elem when elem: term
@@ -1186,9 +1188,6 @@ defmodule Kernel do
       tl([1, 2, 3, :go])
       #=> [2, 3, :go]
 
-      tl([])
-      ** (ArgumentError) argument error
-
       tl([:one])
       #=> []
 
@@ -1198,6 +1197,11 @@ defmodule Kernel do
       tl([:a | %{b: 1}])
       #=> %{b: 1}
 
+  Giving it an empty list raises:
+
+      tl([])
+      #=> ** (ArgumentError) argument error
+
   """
   @doc guard: true
   @spec tl(nonempty_maybe_improper_list(elem, tail)) :: maybe_improper_list(elem, tail) | tail

lib/elixir/lib/list.ex

@@ -831,9 +831,6 @@ defmodule List do
       iex> List.to_existing_atom('🌢 Elixir')
       :"🌢 Elixir"
 
-      iex> List.to_existing_atom('this_atom_will_never_exist')
-      ** (ArgumentError) argument error
-
   """
   @spec to_existing_atom(charlist) :: atom
   def to_existing_atom(charlist) do

lib/elixir/lib/module.ex

@@ -724,9 +724,6 @@ defmodule Module do
 
   ## Examples
 
-      iex> Module.safe_concat([Module, Unknown])
-      ** (ArgumentError) argument error
-
       iex> Module.safe_concat([List, Chars])
       List.Chars
 
@@ -745,9 +742,6 @@ defmodule Module do
 
   ## Examples
 
-      iex> Module.safe_concat(Module, Unknown)
-      ** (ArgumentError) argument error
-
       iex> Module.safe_concat(List, Chars)
       List.Chars
 

lib/elixir/lib/string.ex

@@ -2384,9 +2384,6 @@ defmodule String do
       iex> String.to_existing_atom("my_atom")
       :my_atom
 
-      iex> String.to_existing_atom("this_atom_will_never_exist")
-      ** (ArgumentError) argument error
-
   """
   @spec to_existing_atom(String.t()) :: atom
   def to_existing_atom(string) when is_binary(string) do

lib/elixir/src/elixir_erl_try.erl

@@ -2,7 +2,8 @@
 -export([clauses/3]).
 -include("elixir.hrl").
 -define(REQUIRES_STACKTRACE,
-        ['Elixir.FunctionClauseError', 'Elixir.UndefinedFunctionError', 'Elixir.KeyError']).
+        ['Elixir.FunctionClauseError', 'Elixir.UndefinedFunctionError',
+         'Elixir.KeyError', 'Elixir.ArgumentError', 'Elixir.SystemLimitError']).
 
 clauses(_Meta, Args, S) ->
   Catch = elixir_erl_clauses:get_clauses('catch', Args, 'catch'),

lib/elixir/test/elixir/exception_test.exs

@@ -231,7 +231,9 @@ defmodule ExceptionTest do
 
       return = {:ok, {{:foo, 1, 1}, []}}
       {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
-      assert Exception.format_exit(reason) == "bad supervisor configuration, invalid strategy: :foo"
+
+      assert Exception.format_exit(reason) ==
+               "bad supervisor configuration, invalid strategy: :foo"
 
       return = {:ok, {{:one_for_one, :foo, 1}, []}}
       {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
@@ -261,7 +263,9 @@ defmodule ExceptionTest do
 
       return = {:ok, {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :foo, 1, :worker, []}]}}
       {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
-      assert Exception.format_exit(reason) =~ "bad child specification, invalid restart type: :foo"
+
+      assert Exception.format_exit(reason) =~
+               "bad child specification, invalid restart type: :foo"
 
       return = {
         :ok,
@@ -275,7 +279,9 @@ defmodule ExceptionTest do
       {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
       assert Exception.format_exit(reason) =~ "bad child specification, invalid child type: :foo"
 
-      return = {:ok, {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, 1, :worker, :foo}]}}
+      return =
+        {:ok, {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, 1, :worker, :foo}]}}
+
       {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
       assert Exception.format_exit(reason) =~ "bad child specification, invalid modules: :foo"
 
@@ -705,8 +711,6 @@ defmodule ExceptionTest do
     end
   end
 
-  ## Exception messages
-
   describe "exception messages" do
     import Exception, only: [message: 1]
 
@@ -768,4 +772,45 @@ defmodule ExceptionTest do
       assert %ErlangError{original: :sample} |> message == "Erlang error: :sample"
     end
   end
+
+  if :erlang.system_info(:otp_release) >= '24' do
+    describe "error_info" do
+      test "badarg on erlang" do
+        assert message(:erlang, & &1.element("foo", "bar")) == """
+               errors were found at the given arguments:
+
+                 * 1st argument: not an integer
+                 * 2nd argument: not a tuple
+               """
+      end
+
+      test "badarg on ets" do
+        ets = :ets.new(:foo, [])
+        :ets.delete(ets)
+
+        assert message(:ets, & &1.insert(ets, 1)) == """
+               errors were found at the given arguments:
+
+                 * 1st argument: the table identifier does not refer to an existing ETS table
+                 * 2nd argument: not a tuple
+               """
+      end
+
+      test "system_limit on counters" do
+        assert message(:counters, & &1.new(123_456_789_123_456_789_123_456_789, [])) == """
+               a system limit has been reached due to errors at the given arguments:
+
+                 * 1st argument: counters array size reached a system limit
+               """
+      end
+
+      defp message(arg, fun) do
+        try do
+          fun.(arg)
+        rescue
+          e -> Exception.message(e)
+        end
+      end
+    end
+  end
 end

lib/elixir/test/elixir/kernel_test.exs

@@ -1343,22 +1343,15 @@ defmodule KernelTest do
   test "tl/1" do
     assert tl([:one]) == []
     assert tl([1, 2, 3]) == [2, 3]
-
-    assert_raise ArgumentError, "argument error", fn ->
-      tl(empty_list())
-    end
+    assert_raise ArgumentError, fn -> tl(empty_list()) end
 
     assert tl([:a | :b]) == :b
     assert tl([:a, :b | :c]) == [:b | :c]
   end
 
   test "hd/1" do
     assert hd([1, 2, 3, 4]) == 1
-
-    assert_raise ArgumentError, "argument error", fn ->
-      hd(empty_list())
-    end
-
+    assert_raise ArgumentError, fn -> hd(empty_list()) end
     assert hd([1 | 2]) == 1
   end