Properly handle :erlang.element in Exception blame

Author: José Valim

lib/elixir/lib/exception.ex

@@ -301,8 +301,17 @@ defmodule Exception do
 
   defp rewrite_guard(guard) do
     Macro.prewalk(guard, fn
-      {:., _, [:erlang, call]} -> rewrite_guard_call(call)
-      other -> other
+      {{:., _, [:erlang, :element]}, _, [{{:., _, [:erlang, :+]}, _, [int, 1]}, arg]} ->
+        {:elem, [], [arg, int]}
+
+      {{:., _, [:erlang, :element]}, _, [int, arg]} when is_integer(int) ->
+        {:elem, [], [arg, int - 1]}
+
+      {:., _, [:erlang, call]} ->
+        rewrite_guard_call(call)
+
+      other ->
+        other
     end)
   end
 

lib/elixir/test/elixir/exception_test.exs

@@ -439,34 +439,48 @@ defmodule ExceptionTest do
       end
 
       test "annotates args and clauses from mfa" do
-        {:ok, :def, clauses} = Exception.blame_mfa(Keyword, :pop, [%{}, :key, nil])
+        import PathHelpers
 
-        assert annotated_clauses_to_string(clauses) == [
-                 "{[+keywords+, +key+, +default+], [-is_list(keywords)-]}"
-               ]
+        write_beam(
+          defmodule Blaming do
+            def with_elem(x, y) when elem(x, 1) == 0 and elem(x, y) == 1 do
+              {x, y}
+            end
 
-        {:ok, :def, clauses} = Exception.blame_mfa(Keyword, :fetch, [[], "oops"])
+            def fetch(%module{} = container, key), do: {module, container, key}
+            def fetch(map, key) when is_map(map), do: {map, key}
+            def fetch(list, key) when is_list(list) and is_atom(key), do: {list, key}
+            def fetch(nil, _key), do: nil
 
-        assert annotated_clauses_to_string(clauses) == [
-                 "{[+keywords+, +key+], [+is_list(keywords)+ and -is_atom(key)-]}"
-               ]
+            require Integer
+            def even_and_odd(foo, bar) when Integer.is_even(foo) and Integer.is_odd(bar), do: :ok
+          end
+        )
+
+        :code.delete(Blaming)
+        :code.purge(Blaming)
 
-        {:ok, :def, clauses} = Exception.blame_mfa(Path, :type, [self()])
+        {:ok, :def, clauses} = Exception.blame_mfa(Blaming, :with_elem, [1, 2])
 
         assert annotated_clauses_to_string(clauses) == [
-                 "{[+name+], [-is_list(name)-, -is_binary(name)-]}"
+                 "{[+x+, +y+], [-elem(x, 1) == 0- and -elem(x, y) == 1-]}"
                ]
 
-        {:ok, :def, clauses} = Exception.blame_mfa(Access, :fetch, [self(), "oops"])
+        {:ok, :def, clauses} = Exception.blame_mfa(Blaming, :fetch, [self(), "oops"])
 
         assert annotated_clauses_to_string(clauses) == [
                  "{[-%module{} = container-, +key+], []}",
                  "{[+map+, +key+], [-is_map(map)-]}",
                  "{[+list+, +key+], [-is_list(list)- and -is_atom(key)-]}",
-                 "{[+list+, +key+], [-is_list(list)-]}",
                  "{[-nil-, +_key+], []}"
                ]
 
+        {:ok, :def, clauses} = Exception.blame_mfa(Blaming, :even_and_odd, [1, 1])
+
+        assert annotated_clauses_to_string(clauses) == [
+                 "{[+foo+, +bar+], [+is_integer(foo)+ and -Bitwise.band(foo, 1) == 0- and (+is_integer(bar)+ and +Bitwise.band(bar, 1) == 1+)]}"
+               ]
+
         {:ok, :defmacro, clauses} = Exception.blame_mfa(Kernel, :!, [true])
 
         assert annotated_clauses_to_string(clauses) == [