Raise KeyError for now in map.bad_field

Author: José Valim

lib/elixir/lib/dict.ex

@@ -191,8 +191,6 @@ defmodule Dict do
       iex> d = Enum.into([a: 1], dict_impl.new)
       iex> Dict.fetch!(d, :a)
       1
-      iex> Dict.fetch!(d, :b)
-      ** (KeyError) key not found: :b
 
   """
   @spec fetch!(t, key) :: value | no_return

lib/elixir/lib/dict/behaviour.ex

@@ -79,7 +79,7 @@ defmodule Dict.Behaviour do
       def fetch!(dict, key) do
         case fetch(dict, key) do
           { :ok, value } -> value
-          :error -> raise KeyError, key: key
+          :error -> raise KeyError, key: key, term: dict
         end
       end
 

lib/elixir/lib/exception.ex

@@ -111,9 +111,9 @@ defexception ErlangError, [original: nil] do
   end
 end
 
-defexception KeyError, key: nil do
+defexception KeyError, key: nil, term: nil do
   def message(exception) do
-    "key not found: #{inspect exception.key}"
+    "key #{inspect exception.key} not found in: #{inspect exception.term}"
   end
 end
 

lib/elixir/lib/hash_dict.ex

@@ -60,8 +60,9 @@ defmodule HashDict do
     trie(root: root, size: size + counter)
   end
 
-  def update!(trie(root: root, size: size), key, fun) when is_function(fun, 1) do
-    { root, counter } = do_update(root, key, fn -> raise KeyError, key: key end, fun, key_hash(key))
+  def update!(trie(root: root, size: size) = dict, key, fun) when is_function(fun, 1) do
+    { root, counter } = do_update(root, key, fn -> raise KeyError, key: key, term: dict end,
+                                  fun, key_hash(key))
     trie(root: root, size: size + counter)
   end
 

lib/elixir/lib/keyword.ex

@@ -160,14 +160,14 @@ defmodule Keyword do
       1
 
       iex> Keyword.fetch!([a: 1], :b)
-      ** (KeyError) key not found: :b
+      ** (KeyError) key :b not found in: [a: 1]
 
   """
   @spec fetch!(t, key) :: value | no_return
   def fetch!(keywords, key) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
       { ^key, value } -> value
-      false -> raise(KeyError, key: key)
+      false -> raise(KeyError, key: key, term: keywords)
     end
   end
 
@@ -401,20 +401,24 @@ defmodule Keyword do
       [a: 2]
 
       iex> Keyword.update!([a: 1], :b, &(&1 * 2))
-      ** (KeyError) key not found: :b
+      ** (KeyError) key :b not found in: [a: 1]
 
   """
   @spec update!(t, key, (value -> value)) :: t | no_return
-  def update!([{key, value}|keywords], key, fun) do
+  def update!(keywords, key, fun) do
+    update!(keywords, key, fun, keywords)
+  end
+
+  defp update!([{key, value}|keywords], key, fun, dict) do
     [{key, fun.(value)}|delete(keywords, key)]
   end
 
-  def update!([{_, _} = e|keywords], key, fun) do
-    [e|update!(keywords, key, fun)]
+  defp update!([{_, _} = e|keywords], key, fun, dict) do
+    [e|update!(keywords, key, fun, dict)]
   end
 
-  def update!([], key, _fun) when is_atom(key) do
-    raise(KeyError, key: key)
+  defp update!([], key, _fun, dict) when is_atom(key) do
+    raise(KeyError, key: key, term: dict)
   end
 
   @doc """

lib/elixir/lib/list_dict.ex

@@ -57,7 +57,7 @@ defmodule ListDict do
   def fetch!(dict, key) do
     case fetch(dict, key) do
       { :ok, value } -> value
-      :error -> raise(KeyError, key: key)
+      :error -> raise(KeyError, key: key, term: dict)
     end
   end
 
@@ -109,16 +109,20 @@ defmodule ListDict do
     for { k, _ } = tuple <- dict, not k in keys, do: tuple
   end
 
-  def update!([{key, value}|dict], key, fun) do
-    [{key, fun.(value)}|delete(dict, key)]
+  def update!(list, key, fun) do
+    update!(list, key, fun, list)
+  end
+
+  defp update!([{key, value}|list], key, fun, dict) do
+    [{key, fun.(value)}|delete(list, key)]
   end
 
-  def update!([{_, _} = e|dict], key, fun) do
-    [e|update!(dict, key, fun)]
+  defp update!([{_, _} = e|list], key, fun, dict) do
+    [e|update!(list, key, fun, dict)]
   end
 
-  def update!([], key, _fun) do
-    raise(KeyError, key: key)
+  defp update!([], key, _fun, dict) do
+    raise(KeyError, key: key, term: dict)
   end
 
   def update([{key, value}|dict], key, _initial, fun) do

lib/elixir/lib/map.ex

@@ -89,7 +89,7 @@ defmodule Map do
   def update!(map, key, fun) do
     case :maps.find(key, map) do
       :error ->
-        raise(KeyError, key: key)
+        raise(KeyError, key: key, term: map)
       { :ok, val } ->
         :maps.put(key, fun.(val), map)
     end

lib/elixir/lib/record.ex

@@ -83,7 +83,7 @@ defmodule Record do
       iex> Record.record?(record)
       true
       iex> integer = 13
-      iex> Record.record?(13)
+      iex> Record.record?(integer)
       false
 
   """

lib/elixir/src/elixir_translator.erl

@@ -229,7 +229,11 @@ translate({ { '.', _, [Left, Right] }, Meta, Args }, S)
         true ->
           { Var, _, SV } = elixir_scope:build_var('_', SC),
           TVar = { var, Line, Var },
-          TMap = { tuple, Line, [{ atom, Line, badarg }, TVar] },
+          TMap = { tuple, Line, [
+            { atom, Line, 'Elixir.KeyError' },
+            { atom, Line, '__exception__' },
+            TRight,
+            TVar] },
 
           { { 'case', -1, TLeft, [
             { clause, -1,

lib/elixir/test/elixir/map_test.exs

@@ -93,7 +93,7 @@ defmodule MapTest do
   test "map access" do
     assert two_items_map.a == 1
 
-    assert_raise ArgumentError, fn ->
+    assert_raise KeyError, fn ->
       two_items_map.c
     end
   end