Clean up and speed up exceptions

Author: José Valim

lib/elixir/lib/exception.ex

@@ -1,3 +1,94 @@
+defexception RuntimeError,      message: "runtime error"
+defexception ArgumentError,     message: "argument error"
+defexception ArithmeticError,   message: "bad argument in arithmetic expression"
+defexception SystemLimitError,  message: "a system limit has been reached"
+
+defexception SyntaxError, [file: nil, line: nil, description: "syntax error"] do
+  def message(exception) do
+    "#{Exception.format_file_line(exception.file, exception.line, nil)}#{exception.description}"
+  end
+end
+
+defexception TokenMissingError, [file: nil, line: nil, description: "expression is incomplete"] do
+  def message(exception) do
+    "#{Exception.format_file_line(exception.file, exception.line, nil)}#{exception.description}"
+  end
+end
+
+defexception CompileError, [file: nil, line: nil, description: "compile error"] do
+  def message(exception) do
+    "#{Exception.format_file_line(exception.file, exception.line, nil)}#{exception.description}"
+  end
+end
+
+defexception BadFunctionError, [actual: nil] do
+  def message(exception) do
+    "expected a function, got: #{inspect(exception.actual)}"
+  end
+end
+
+defexception MatchError, [actual: nil] do
+  def message(exception) do
+    "no match of right hand side value: #{inspect(exception.actual)}"
+  end
+end
+
+defexception CaseClauseError, [actual: nil] do
+  def message(exception) do
+    "no case clause matching: #{inspect(exception.actual)}"
+  end
+end
+
+defexception BadArityError, [function: nil, args: nil] do
+  def message(exception) do
+    "bad arity error: #{inspect(exception.function)} called with #{inspect(exception.args)}"
+  end
+end
+
+defexception UndefinedFunctionError, [module: nil, function: nil, arity: nil] do
+  def message(exception) do
+    if exception.function do
+      formatted = Exception.format_module_fun_arity exception.module, exception.function, exception.arity
+      "undefined function: #{formatted}"
+    else
+      "undefined function"
+    end
+  end
+end
+
+defexception FunctionClauseError, [module: nil, function: nil, arity: nil] do
+  def message(exception) do
+    if exception.function do
+      formatted = Exception.format_module_fun_arity exception.module, exception.function, exception.arity
+      "no function clause matching in #{formatted}"
+    else
+      "no function clause matches"
+    end
+  end
+end
+
+defexception Protocol.UndefinedError, [protocol: nil, structure: nil] do
+  def message(exception) do
+    "protocol #{inspect exception.protocol} not implemented for #{inspect exception.structure}"
+  end
+end
+
+defexception ErlangError, [original: nil] do
+  def message(exception) do
+    "erlang error: #{inspect(exception.original)}"
+  end
+end
+
+defexception KeyError, key: nil do
+  def message(exception) do
+    "key not found: #{inspect exception.key}"
+  end
+end
+
+defexception Enum.OutOfBoundsError, message: "out of bounds error"
+
+defexception Enum.EmptyError, message: "empty error"
+
 defmodule Exception do
   @moduledoc """
   Several convenience functions to work and pretty print
@@ -14,47 +105,49 @@ defmodule Exception do
   end
 
   def normalize(:badarg) do
-    ArgumentError.new
+    ArgumentError[]
   end
 
   def normalize(:badarith) do
-    ArithmeticError.new
+    ArithmeticError[]
   end
 
   def normalize(:system_limit) do
-    SystemLimitError.new
+    SystemLimitError[]
   end
 
   def normalize({ :badarity, { fun, args } }) do
-    BadArityError.new(function: fun, args: args)
+    BadArityError[function: fun, args: args]
   end
 
   def normalize({ :badfun, actual }) do
-    BadFunctionError.new(actual: actual)
+    BadFunctionError[actual: actual]
   end
 
   def normalize({ :badmatch, actual }) do
-    MatchError.new(actual: actual)
+    MatchError[actual: actual]
   end
 
   def normalize({ :case_clause, actual }) do
-    CaseClauseError.new(actual: actual)
+    CaseClauseError[actual: actual]
   end
 
   def normalize(:undef) do
-    UndefinedFunctionError.new from_stacktrace(:erlang.get_stacktrace)
+    { mod, fun, arity } = from_stacktrace(:erlang.get_stacktrace)
+    UndefinedFunctionError[module: mod, function: fun, arity: arity]
   end
 
   def normalize(:function_clause) do
-    FunctionClauseError.new from_stacktrace(:erlang.get_stacktrace)
+    { mod, fun, arity } = from_stacktrace(:erlang.get_stacktrace)
+    FunctionClauseError[module: mod, function: fun, arity: arity]
   end
 
   def normalize({ :badarg, payload }) do
-    ArgumentError.new message: "argument error: #{inspect(payload)}"
+    ArgumentError[message: "argument error: #{inspect(payload)}"]
   end
 
   def normalize(other) do
-    ErlangError.new original: other
+    ErlangError[original: other]
   end
 
   @doc """
@@ -122,14 +215,6 @@ defmodule Exception do
 
   ## Helpers
 
-  # Check the given module is a valid exception record.
-  @doc false
-  def check!(module) do
-    unless :erlang.function_exported(module, :message, 1) do
-      raise "Expected #{inspect module} to implement message/1"
-    end
-  end
-
   # Format fun and arity
   @doc false
   def format_fun_arity(fun, arity) do
@@ -184,103 +269,15 @@ defmodule Exception do
     end
   end
 
-  defp from_stacktrace([{ module, function, arity, _ }|_]) do
-    [module: module, function: function, arity: arity]
-  end
-
-  defp from_stacktrace(_), do: []
-end
-
-defexception RuntimeError,      message: "runtime error"
-defexception ArgumentError,     message: "argument error"
-defexception ArithmeticError,   message: "bad argument in arithmetic expression"
-defexception SystemLimitError,  message: "a system limit has been reached"
-
-defexception SyntaxError, [file: nil, line: nil, description: "syntax error"] do
-  def message(exception) do
-    "#{Exception.format_file_line(exception.file, exception.line, nil)}#{exception.description}"
-  end
-end
-
-defexception TokenMissingError, [file: nil, line: nil, description: "expression is incomplete"] do
-  def message(exception) do
-    "#{Exception.format_file_line(exception.file, exception.line, nil)}#{exception.description}"
-  end
-end
-
-defexception CompileError, [file: nil, line: nil, description: "compile error"] do
-  def message(exception) do
-    "#{Exception.format_file_line(exception.file, exception.line, nil)}#{exception.description}"
-  end
-end
-
-defexception BadFunctionError, [actual: nil] do
-  def message(exception) do
-    "expected a function, got: #{inspect(exception.actual)}"
+  defp from_stacktrace([{ module, function, args, _ }|_]) when is_list(args) do
+    { module, function, length(args) }
   end
-end
-
-defexception MatchError, [actual: nil] do
-  def message(exception) do
-    "no match of right hand side value: #{inspect(exception.actual)}"
-  end
-end
-
-defexception CaseClauseError, [actual: nil] do
-  def message(exception) do
-    "no case clause matching: #{inspect(exception.actual)}"
-  end
-end
 
-defexception BadArityError, [function: nil, args: nil] do
-  def message(exception) do
-    "bad arity error: #{inspect(exception.function)} called with #{inspect(exception.args)}"
-  end
-end
-
-defexception UndefinedFunctionError, [module: nil, function: nil, arity: nil] do
-  def message(exception) do
-    if exception.function do
-      formatted = Exception.format_module_fun_arity exception.module, exception.function, to_arity(exception.arity)
-      "undefined function: #{formatted}"
-    else
-      "undefined function"
-    end
-  end
-
-  defp to_arity(arity) when is_integer(arity), do: arity
-  defp to_arity(list)  when is_list(list),     do: length(list)
-end
-
-defexception FunctionClauseError, [module: nil, function: nil, arity: nil] do
-  def message(exception) do
-    if exception.function do
-      formatted = Exception.format_module_fun_arity exception.module, exception.function, exception.arity
-      "no function clause matching: #{formatted}"
-    else
-      "no function clause matches"
-    end
-  end
-end
-
-defexception Protocol.UndefinedError, [protocol: nil, structure: nil] do
-  def message(exception) do
-    "protocol #{inspect exception.protocol} not implemented for #{inspect exception.structure}"
-  end
-end
-
-defexception ErlangError, [original: nil] do
-  def message(exception) do
-    "erlang error: #{inspect(exception.original)}"
+  defp from_stacktrace([{ module, function, arity, _ }|_]) do
+    { module, function, arity }
   end
-end
 
-defexception KeyError, key: nil do
-  def message(exception) do
-    "key not found: #{inspect exception.key}"
+  defp from_stacktrace(_) do
+    { nil, nil, nil }
   end
 end
-
-defexception Enum.OutOfBoundsError, message: "out of bounds error"
-
-defexception Enum.EmptyError, message: "empty error"

lib/elixir/lib/kernel.ex

@@ -1569,7 +1569,10 @@ defmodule Kernel do
 
     quote do
       unquote(record)
-      Exception.check! unquote(name)
+      name = unquote(name)
+      unless :erlang.function_exported(name, :message, 1) do
+        raise "expected exception #{inspect name} to implement message/1"
+      end
     end
   end
 

lib/elixir/test/elixir/exception_test.exs

@@ -62,15 +62,11 @@ defmodule Kernel.ExceptionTest do
   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: Foo, function: :bar, arity: []).message == "undefined function: Foo.bar/0"
-    assert UndefinedFunctionError.new(module: :foo,  function: :bar, arity: []).message == "undefined function: :foo.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: Foo.bar/1"
-    assert FunctionClauseError.new(module: Foo, function: :bar, arity: []).message == "no function clause matching: Foo.bar()"
-    assert FunctionClauseError.new(module: :foo,  function: :bar, arity: []).message == "no function clause matching: :foo.bar()"
+    assert FunctionClauseError.new(module: Foo, function: :bar, arity: 1).message == "no function clause matching in Foo.bar/1"
   end
 
   test :erlang_error_message do

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

@@ -146,7 +146,7 @@ defmodule Kernel.RescueTest do
       x in [FunctionClauseError] -> x.message
     end
 
-    assert result == "no function clause matching: Kernel.RescueTest.zero(1)"
+    assert result == "no function clause matching in Kernel.RescueTest.zero/1"
   end
 
   test :badarg_error do

lib/ex_unit/test/ex_unit/assertions_test.exs

@@ -219,7 +219,7 @@ defmodule ExUnit.AssertionsTest do
     end
   rescue
     error in [ExUnit.AssertionError] ->
-      "Expected exception SyntaxError, got FunctionClauseError (no function clause matching: :lists.flatten(1))" = error.message
+      "Expected exception SyntaxError, got FunctionClauseError (no function clause matching in :lists.flatten/1)" = error.message
   end
 
   test :assert_operator_greater_pass do