Use Exception.message/1 instead of exception.message

Author: José Valim

CHANGELOG.md

@@ -20,6 +20,7 @@
 
 * Soft deprecations (no warnings emitted)
   * [Application] use Application.Behaviour is deprecated in favor of use Application
+  * [Exception] Use `Exception.message/1` to retrieve exception messages instead of `exception.message`
   * [Mix] `Mix.project/0` is deprecated in favor of `Mix.Project.config/0`
   * [Process] `Process.spawn/1`, `Process.spawn/3`, `Process.spawn_link/1`, `Process.spawn_link/3`, `Process.spawn_monitor/1`, `Process.spawn_monitor/3`, `Process.send/2` and `Process.self/0` are deprecated in favor of the ones in Kernel
 

lib/elixir/lib/exception.ex

@@ -186,7 +186,14 @@ defmodule Exception do
   Gets the message for an exception.
   """
   def message(exception) do
-    exception.message
+    try do
+      exception.message
+    rescue
+      e ->
+        raise ArgumentError, message:
+          "Got #{inspect e.__record__(:name)} with message " <>
+          "\"#{message(e)}\" while retrieving message for #{inspect(exception)}"
+    end
   end
 
   @doc """
@@ -292,7 +299,7 @@ defmodule Exception do
 
   def format_banner(:error, exception, stacktrace) do
     exception = normalize_error(exception, stacktrace)
-    "** (" <> inspect(exception.__record__(:name)) <> ") " <> exception.message
+    "** (" <> inspect(exception.__record__(:name)) <> ") " <> message(exception)
   end
 
   def format_banner(:throw, reason, _stacktrace) do

lib/elixir/lib/inspect/algebra.ex

@@ -162,9 +162,9 @@ defmodule Inspect.Algebra do
       rescue
         e ->
           res = Inspect.Tuple.inspect(arg, opts)
-          IO.puts :stderr, "** (Inspect.Error) Got #{inspect e.__record__(:name)} with message " <>
-                           "#{e.message} while inspecting #{pretty(res, opts.width)}"
-          res
+          raise ArgumentError, message:
+            "Got #{inspect e.__record__(:name)} with message " <>
+            "#{Exception.message(e)} while inspecting #{pretty(res, opts.width)}"
       end
     else
       Inspect.Tuple.inspect(arg, opts)
@@ -178,9 +178,9 @@ defmodule Inspect.Algebra do
       rescue
         e ->
           res = Inspect.Map.inspect(map, opts)
-          IO.puts :stderr, "** (Inspect.Error) Got #{inspect e.__record__(:name)} with message " <>
-                           "#{e.message} while inspecting #{pretty(res, opts.width)}"
-          res
+          raise ArgumentError, message:
+            "Got #{inspect e.__record__(:name)} with message " <>
+            "\"#{Exception.message(e)}\" while inspecting #{pretty(res, opts.width)}"
       end
     else
       Inspect.Map.inspect(map, opts)

lib/elixir/lib/kernel.ex

@@ -1744,7 +1744,7 @@ defmodule Kernel do
       rescue
         exception ->
           stacktrace = System.stacktrace
-          if exception.message == "Oops" do
+          if Exception.message(exception) == "Oops" do
             raise exception, [], stacktrace
           end
       end

lib/elixir/test/elixir/access_test.exs

@@ -39,7 +39,8 @@ defmodule AccessTest do
       foo = :foo
       foo[:atom]
     end
-    assert exception.message == "The access protocol can only be invoked for atoms " <>
-                                "at compilation time, tried to invoke it for :foo"
+    assert Exception.message(exception) ==
+           "The access protocol can only be invoked for atoms " <>
+           "at compilation time, tried to invoke it for :foo"
   end
 end

lib/elixir/test/elixir/exception_test.exs

@@ -6,13 +6,41 @@ defmodule Kernel.ExceptionTest do
   # Ensure fields passed through an expression are valid
   defexception Custom, ~w(message)a
 
+  test "raise preserves the stacktrace" do
+    stacktrace =
+      try do
+        raise "a"
+      rescue _ ->
+        [top|_] = System.stacktrace
+        top
+      end
+    file = __ENV__.file |> Path.relative_to_cwd |> List.from_char_data!
+    assert {Kernel.ExceptionTest, :"test raise preserves the stacktrace", _,
+           [file: ^file, line: 12]} = stacktrace
+  end
+
   test "is_exception" do
     assert is_exception(RuntimeError.new)
     refute is_exception(empty_tuple)
     refute is_exception(a_tuple)
     refute is_exception(a_list)
   end
 
+  test "message" do
+    defmodule BadException do
+      def message(_) do
+        raise "oops"
+      end
+    end
+
+    message = "Got RuntimeError with message \"oops\" " <>
+              "while retrieving message for {Kernel.ExceptionTest.BadException}"
+
+    assert_raise ArgumentError, message, fn ->
+      Exception.message({BadException})
+    end
+  end
+
   test "normalize" do
     assert Exception.normalize(:throw, :badarg) == :badarg
     assert is_record Exception.normalize(:error, :badarg), ArgumentError
@@ -161,49 +189,36 @@ defmodule Kernel.ExceptionTest do
            ~r"#Function<\d\.\d+/0 in Kernel\.ExceptionTest\.test format_fa/1>/1"
   end
 
+  import Exception, only: [message: 1]
+
   test "runtime error message" do
-    assert RuntimeError.new.message == "runtime error"
-    assert RuntimeError.new(message: "exception").message == "exception"
+    assert RuntimeError.new |> message == "runtime error"
+    assert RuntimeError.new(message: "exception") |> message == "exception"
   end
 
   test "argument error message" do
-    assert ArgumentError.new.message == "argument error"
-    assert ArgumentError.new(message: "exception").message == "exception"
+    assert ArgumentError.new |> message == "argument error"
+    assert ArgumentError.new(message: "exception") |> message == "exception"
   end
 
   test "undefined function message" do
-    assert UndefinedFunctionError.new.message == "undefined function"
-    assert UndefinedFunctionError.new(module: Foo, function: :bar, arity: 1).message == "undefined function: Foo.bar/1"
-    assert UndefinedFunctionError.new(module: nil, function: :bar, arity: 0).message == "undefined function: nil.bar/0"
+    assert UndefinedFunctionError.new |> message == "undefined function"
+    assert UndefinedFunctionError.new(module: Foo, function: :bar, arity: 1) |> message ==
+           "undefined function: Foo.bar/1"
+    assert UndefinedFunctionError.new(module: nil, function: :bar, arity: 0) |> message ==
+           "undefined function: nil.bar/0"
   end
 
   test "function clause message" do
-    assert FunctionClauseError.new.message == "no function clause matches"
-    assert FunctionClauseError.new(module: Foo, function: :bar, arity: 1).message == "no function clause matching in Foo.bar/1"
+    assert FunctionClauseError.new |> message ==
+           "no function clause matches"
+    assert FunctionClauseError.new(module: Foo, function: :bar, arity: 1) |> message ==
+           "no function clause matching in Foo.bar/1"
   end
 
   test "erlang error message" do
-    assert ErlangError.new(original: :sample).message == "erlang error: :sample"
-  end
-
-  test "raise preserves the stacktrace" do
-    stacktrace =
-      try do
-        raise "a"
-      rescue _ ->
-        [top|_] = System.stacktrace
-        top
-      end
-    file = __ENV__.file |> Path.relative_to_cwd |> List.from_char_data!
-    assert {Kernel.ExceptionTest, :"test raise preserves the stacktrace", _,
-           [file: ^file, line: 192]} = stacktrace
-  end
-
-  test "defexception" do
-    defexception SampleError, message: nil do
-      # Check do block is properly inline
-      def exception(_), do: SampleError[message: "hello"]
-    end
+    assert ErlangError.new(original: :sample) |> message ==
+           "erlang error: :sample"
   end
 
   defp empty_tuple, do: {}

lib/elixir/test/elixir/inspect_test.exs

@@ -165,14 +165,6 @@ defmodule Inspect.TupleTest do
     assert inspect({Rec[value: 1], 1}) == "{Inspect.TupleTest.Rec[value: 1], 1}"
   end
 
-  test :false_positives do
-    import ExUnit.CaptureIO
-
-    assert capture_io(:stderr, fn ->
-      assert inspect({Range, nil}) == "{Range, nil}"
-    end) =~ "** (Inspect.Error) Got FunctionClauseError with message no function clause matching in Inspect.Range.inspect/2"
-  end
-
   test :empty do
     assert inspect({}) == "{}"
   end
@@ -303,12 +295,12 @@ defmodule Inspect.MapTest do
   end
 
   test :bad_implementation do
-    import ExUnit.CaptureIO
+    msg = "Got RuntimeError with message \"failing\" " <>
+          "while inspecting %{__struct__: Inspect.MapTest.Failing, key: 0}"
 
-    assert capture_io(:stderr, fn ->
+    assert_raise ArgumentError, msg, fn ->
       inspect(%Failing{})
-    end) =~ ("** (Inspect.Error) Got RuntimeError with message failing while inspecting " <>
-             "%{__struct__: Inspect.MapTest.Failing, key: 0}")
+    end
   end
 end
 

lib/elixir/test/elixir/kernel/overridable_test.exs

@@ -144,8 +144,9 @@ defmodule Kernel.OverridableTest do
       flunk "expected eval to fail"
     rescue
       error ->
-        assert error.message == ("nofile:4: no super defined for foo/0 in module Foo.Forwarding. " <>
-          "Overridable functions available are: bar/0")
+        assert Exception.message(error) ==
+          "nofile:4: no super defined for foo/0 in module Foo.Forwarding. " <>
+          "Overridable functions available are: bar/0"
     end
   end
 end

lib/elixir/test/elixir/kernel/rescue_test.exs

@@ -51,7 +51,7 @@ defmodule Kernel.RescueTest do
     result = try do
       raise "an exception"
     rescue
-      x in [RuntimeError] -> x.message
+      x in [RuntimeError] -> Exception.message(x)
     catch
       :error, _ -> false
     end
@@ -75,7 +75,7 @@ defmodule Kernel.RescueTest do
     result = try do
       Certainly.Undefined.function(1, 2, 3)
     rescue
-      x in [named] -> x.message
+      x in [named] -> Exception.message(x)
     catch
       :error, _ -> "didn't catch it"
     end
@@ -87,7 +87,7 @@ defmodule Kernel.RescueTest do
     result = try do
       raise "an exception"
     rescue
-      x in _ -> x.message
+      x in _ -> Exception.message(x)
     end
 
     assert result == "an exception"
@@ -99,7 +99,7 @@ defmodule Kernel.RescueTest do
     result = try do
       raise RuntimeError, message: "an exception"
     rescue
-      x in [expected, AnotherError] -> x.message
+      x in [expected, AnotherError] -> Exception.message(x)
     catch
       :error, _ -> false
     end
@@ -111,7 +111,7 @@ defmodule Kernel.RescueTest do
     result = try do
       :erlang.error(:sample)
     rescue
-      x in [RuntimeError, ErlangError] -> x.message
+      x in [RuntimeError, ErlangError] -> Exception.message(x)
     end
 
     assert result == "erlang error: :sample"
@@ -121,7 +121,7 @@ defmodule Kernel.RescueTest do
     result = try do
       DoNotExist.for_sure()
     rescue
-      x in [UndefinedFunctionError] -> x.message
+      x in [UndefinedFunctionError] -> Exception.message(x)
     end
 
     assert result == "undefined function: DoNotExist.for_sure/0"
@@ -131,7 +131,7 @@ defmodule Kernel.RescueTest do
     result = try do
       zero(1)
     rescue
-      x in [FunctionClauseError] -> x.message
+      x in [FunctionClauseError] -> Exception.message(x)
     end
 
     assert result == "no function clause matching in Kernel.RescueTest.zero/1"
@@ -141,7 +141,7 @@ defmodule Kernel.RescueTest do
     result = try do
       :erlang.error(:badarg)
     rescue
-      x in [ArgumentError] -> x.message
+      x in [ArgumentError] -> Exception.message(x)
     end
 
     assert result == "argument error"
@@ -151,7 +151,7 @@ defmodule Kernel.RescueTest do
     result = try do
       :erlang.error({:badarg, [1, 2, 3]})
     rescue
-      x in [ArgumentError] -> x.message
+      x in [ArgumentError] -> Exception.message(x)
     end
 
     assert result == "argument error: [1, 2, 3]"
@@ -161,7 +161,7 @@ defmodule Kernel.RescueTest do
     result = try do
       :erlang.error(:badarith)
     rescue
-      x in [ArithmeticError] -> x.message
+      x in [ArithmeticError] -> Exception.message(x)
     end
 
     assert result == "bad argument in arithmetic expression"
@@ -174,7 +174,7 @@ defmodule Kernel.RescueTest do
     result = try do
       fun.(1, 2)
     rescue
-      x in [BadArityError] -> x.message
+      x in [BadArityError] -> Exception.message(x)
     end
 
     assert result == string
@@ -185,7 +185,7 @@ defmodule Kernel.RescueTest do
     result = try do
       x.(2)
     rescue
-      x in [BadFunctionError] -> x.message
+      x in [BadFunctionError] -> Exception.message(x)
     end
 
     assert result == "expected a function, got: :example"
@@ -196,7 +196,7 @@ defmodule Kernel.RescueTest do
     result = try do
       ^x = zero(0)
     rescue
-      x in [MatchError] -> x.message
+      x in [MatchError] -> Exception.message(x)
     end
 
     assert result == "no match of right hand side value: 0"
@@ -209,7 +209,7 @@ defmodule Kernel.RescueTest do
         ^x -> nil
       end
     rescue
-      x in [CaseClauseError] -> x.message
+      x in [CaseClauseError] -> Exception.message(x)
     end
 
     assert result == "no case clause matching: 0"
@@ -225,7 +225,7 @@ defmodule Kernel.RescueTest do
           :ok
       end
     rescue
-      x in [TryClauseError] -> x.message
+      x in [TryClauseError] -> Exception.message(x)
     end
 
     assert result == "no try clause matching: :example"
@@ -236,7 +236,7 @@ defmodule Kernel.RescueTest do
     result = try do
       DoNotExist.for_sure()
     rescue
-      x in [expected] -> x.message
+      x in [expected] -> Exception.message(x)
     end
 
     assert result == "undefined function: DoNotExist.for_sure/0"
@@ -246,7 +246,7 @@ defmodule Kernel.RescueTest do
     result = try do
       DoNotExist.for_sure()
     rescue
-      x in [ErlangError] -> x.message
+      x in [ErlangError] -> Exception.message(x)
     end
 
     assert result == "undefined function: DoNotExist.for_sure/0"
@@ -260,7 +260,7 @@ defmodule Kernel.RescueTest do
     result = try do
       DoNotExist.for_sure()
     rescue
-      x in exceptions -> x.message
+      x in exceptions -> Exception.message(x)
     end
 
     assert result == "undefined function: DoNotExist.for_sure/0"