Merge pull request #2294 from ericmj/reraise

reraise should work like raise

Author: José Valim

lib/elixir/lib/kernel.ex

@@ -1328,12 +1328,14 @@ defmodule Kernel do
   end
 
   @doc """
-  Raises an error.
+  Raises an exception.
 
   If the argument is a binary, it raises `RuntimeError`
   using the given argument as message.
 
-  If anything else, becomes a call to `raise(argument, [])`.
+  If an atom, it will become a call to `raise(atom, [])`.
+
+  If anything else, it will just raise the given exception.
 
   ## Examples
 
@@ -1372,15 +1374,19 @@ defmodule Kernel do
       _ ->
         quote do
           case unquote(msg) do
-            msg when is_binary(msg) -> :erlang.error RuntimeError.exception(msg)
-            msg -> :erlang.error msg.exception([])
+            msg when is_binary(msg) ->
+              :erlang.error RuntimeError.exception(msg)
+            atom when is_atom(atom) ->
+              :erlang.error atom.exception([])
+            %{__struct__: struct, __exception__: true} = other when is_atom(struct) ->
+              :erlang.error other
           end
         end
     end
   end
 
   @doc """
-  Raises an error.
+  Raises an exception.
 
   Calls `.exception` on the given argument passing
   the attributes in order to retrieve the appropriate exception
@@ -1402,7 +1408,16 @@ defmodule Kernel do
   end
 
   @doc """
-  Re-raises an exception with the given stacktrace.
+  Raises an exception preserving a previous stacktrace.
+
+  Works like `raise/1` but does not generate a new stacktrace.
+
+  Notice that `System.stacktrace` returns the stacktrace
+  of the last exception. That said, it is common to assign
+  the stacktrace as the first expression inside a `rescue`
+  clause as any other exception potentially raised (and
+  rescued) in between the rescue clause and the raise call
+  may change the `System.stacktrace` value.
 
   ## Examples
 
@@ -1415,24 +1430,59 @@ defmodule Kernel do
             reraise exception, stacktrace
           end
       end
-
-  Notice that `System.stacktrace` returns the stacktrace
-  of the last exception. That said, it is common to assign
-  the stacktrace as the first expression inside a `rescue`
-  clause as any other exception potentially raised (and
-  rescued) in between the rescue clause and the raise call
-  may change the `System.stacktrace` value.
   """
-  defmacro reraise(exception, stacktrace) do
-    quote do
-      :erlang.raise :error, unquote(exception), unquote(stacktrace)
+  defmacro reraise(msg, stacktrace) do
+    # Try to figure out the type at compilation time
+    # to avoid dead code and make dialyzer happy.
+
+    case Macro.expand(msg, __CALLER__) do
+      msg when is_binary(msg) ->
+        quote do
+          :erlang.raise :error, RuntimeError.exception(unquote(msg)), unquote(stacktrace)
+        end
+      {:<<>>, _, _} = msg ->
+        quote do
+          :erlang.raise :error, RuntimeError.exception(unquote(msg)), unquote(stacktrace)
+        end
+      alias when is_atom(alias) ->
+        quote do
+          :erlang.raise :error, unquote(alias).exception([]), unquote(stacktrace)
+        end
+      msg ->
+        quote do
+          stacktrace = unquote(stacktrace)
+          case unquote(msg) do
+            msg when is_binary(msg) ->
+              :erlang.raise :error, RuntimeError.exception(msg), stacktrace
+            atom when is_atom(atom) ->
+              :erlang.raise :error, atom.exception([]), stacktrace
+            %{__struct__: struct, __exception__: true} = other when is_atom(struct) ->
+              :erlang.raise :error, other, stacktrace
+          end
+        end
     end
   end
 
-  @doc false
-  defmacro raise(exception, _attrs, stacktrace) do
+  @doc """
+  Raises an exception preserving a previous stacktrace.
+
+  Works like `raise/2` but does not generate a new stacktrace.
+
+  See `reraise/2` for more details.
+
+  ## Examples
+
+      try do
+        raise "Oops"
+      rescue
+        exception ->
+          stacktrace = System.stacktrace
+          reraise WrapperError, [exception: exception], stacktrace
+      end
+  """
+  defmacro reraise(exception, attrs, stacktrace) do
     quote do
-      :erlang.raise :error, unquote(exception), unquote(stacktrace)
+      :erlang.raise :error, unquote(exception).exception(unquote(attrs)), unquote(stacktrace)
     end
   end
 
@@ -2894,7 +2944,7 @@ defmodule Kernel do
     implemented;
 
   Since exceptions are structs, all the API supported by `defstruct/1`
-  is available to in `defexception/1`.
+  is also available in `defexception/1`.
 
   ## Raising exceptions
 

lib/elixir/lib/stream.ex

@@ -656,8 +656,9 @@ defmodule Stream do
           user.(val, user_acc)
         catch
           kind, reason ->
+            stacktrace = System.stacktrace
             next.({:halt, next_acc})
-            :erlang.raise(kind, reason, :erlang.get_stacktrace)
+            :erlang.raise(kind, reason, stacktrace)
         else
           {[], user_acc} ->
             do_transform(user_acc, user, fun, next_acc, next, inner_acc, inner)
@@ -700,8 +701,9 @@ defmodule Stream do
         next.({:halt, next_acc})
         {:halted, h}
       kind, reason ->
+        stacktrace = System.stacktrace
         next.({:halt, next_acc})
-        :erlang.raise(kind, reason, :erlang.get_stacktrace)
+        :erlang.raise(kind, reason, stacktrace)
     else
       {_, acc} ->
         do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner)
@@ -835,8 +837,9 @@ defmodule Stream do
       do_zip(zips, acc, callback, [], [])
     catch
       kind, reason ->
+        stacktrace = System.stacktrace
         do_zip_close(zips)
-        :erlang.raise(kind, reason, :erlang.get_stacktrace)
+        :erlang.raise(kind, reason, stacktrace)
     else
       {:next, buffer, acc} ->
         do_zip(buffer, acc, callback)
@@ -1006,8 +1009,9 @@ defmodule Stream do
       end
     catch
       kind, reason ->
+        stacktrace = System.stacktrace
         after_fun.(next_acc)
-        :erlang.raise(kind, reason, :erlang.get_stacktrace)
+        :erlang.raise(kind, reason, stacktrace)
     else
       nil ->
         after_fun.(next_acc)

lib/elixir/test/elixir/kernel/rescue_test.exs renamed to lib/elixir/test/elixir/kernel/raise_test.exs

@@ -1,8 +1,138 @@
 Code.require_file "../test_helper.exs", __DIR__
 
-defmodule Kernel.RescueTest do
+defmodule Kernel.RaiseTest do
   use ExUnit.Case, async: true
 
+  # Silence warnings
+  defp atom, do: RuntimeError
+  defp binary, do: "message"
+  defp opts, do: [message: "message"]
+  defp struct, do: %RuntimeError{message: "message"}
+
+  @trace [{:foo, :bar, 0, []}]
+
+  test "raise message" do
+    assert_raise RuntimeError, "message", fn ->
+      raise "message"
+    end
+
+    assert_raise RuntimeError, "message", fn ->
+      var = binary()
+      raise var
+    end
+  end
+
+  test "raise with no arguments" do
+    assert_raise RuntimeError, fn ->
+      raise RuntimeError
+    end
+
+    assert_raise RuntimeError, fn ->
+      var = atom()
+      raise var
+    end
+  end
+
+  test "raise with arguments" do
+    assert_raise RuntimeError, "message", fn ->
+      raise RuntimeError, message: "message"
+    end
+
+    assert_raise RuntimeError, "message", fn ->
+      atom = atom()
+      opts = opts()
+      raise atom, opts
+    end
+  end
+
+  test "raise existing exception" do
+    assert_raise RuntimeError, "message", fn ->
+      raise %RuntimeError{message: "message"}
+    end
+
+    assert_raise RuntimeError, "message", fn ->
+      var = struct()
+      raise var
+    end
+  end
+
+  test "reraise message" do
+    try do
+      reraise "message", @trace
+      flunk "should not reach"
+    rescue
+      RuntimeError ->
+        assert @trace == :erlang.get_stacktrace()
+    end
+
+    try do
+      var = binary()
+      reraise var, @trace
+      flunk "should not reach"
+    rescue
+      RuntimeError ->
+        assert @trace == :erlang.get_stacktrace()
+    end
+  end
+
+  test "reraise with no arguments" do
+    try do
+      reraise RuntimeError, @trace
+      flunk "should not reach"
+    rescue
+      RuntimeError ->
+        assert @trace == :erlang.get_stacktrace()
+    end
+
+    try do
+      var = atom()
+      reraise var, @trace
+      flunk "should not reach"
+    rescue
+      RuntimeError ->
+        assert @trace == :erlang.get_stacktrace()
+    end
+  end
+
+  test "reraise with arguments" do
+    try do
+      reraise RuntimeError, [message: "message"], @trace
+      flunk "should not reach"
+    rescue
+      RuntimeError ->
+        assert @trace == :erlang.get_stacktrace()
+    end
+
+    try do
+      atom = atom()
+      opts = opts()
+      reraise atom, opts, @trace
+      flunk "should not reach"
+    rescue
+      RuntimeError ->
+        assert @trace == :erlang.get_stacktrace()
+    end
+  end
+
+  test "reraise existing exception" do
+    try do
+      reraise %RuntimeError{message: "message"}, @trace
+      flunk "should not reach"
+    rescue
+      RuntimeError ->
+        assert @trace == :erlang.get_stacktrace()
+    end
+
+    try do
+      var = struct()
+      reraise var, @trace
+      flunk "should not reach"
+    rescue
+      RuntimeError ->
+        assert @trace == :erlang.get_stacktrace()
+    end
+  end
+
   test :rescue_with_underscore_no_exception do
     result = try do
       RescueUndefinedModule.go
@@ -106,7 +236,7 @@ defmodule Kernel.RescueTest do
       x in [FunctionClauseError] -> Exception.message(x)
     end
 
-    assert result == "no function clause matching in Kernel.RescueTest.zero/1"
+    assert result == "no function clause matching in Kernel.RaiseTest.zero/1"
   end
 
   test :badarg_error do

lib/ex_unit/lib/ex_unit/doc_test.ex

@@ -235,10 +235,10 @@ defmodule ExUnit.DocTest do
         unquote_splicing(tests)
       rescue
         e in [ExUnit.AssertionError] ->
-          raise e, [], stack
+          reraise e, [], stack
 
         error ->
-          raise ExUnit.AssertionError,
+          reraise ExUnit.AssertionError,
             [message: "Doctest failed: got #{inspect(elem(error, 0))} with message #{Exception.message(error)}",
              expr: unquote(whole_expr)],
             stack
@@ -255,7 +255,7 @@ defmodule ExUnit.DocTest do
       case unquote(expr_ast) do
         ^expected -> :ok
         actual ->
-          raise ExUnit.AssertionError,
+          reraise ExUnit.AssertionError,
             [message: "Doctest failed",
               expr: "#{unquote(String.strip(expr))} === #{unquote(String.strip(expected))}",
               left: actual],
@@ -273,7 +273,7 @@ defmodule ExUnit.DocTest do
       case unquote(expr_ast) do
         ^expected -> :ok
         actual ->
-          raise ExUnit.AssertionError,
+          reraise ExUnit.AssertionError,
             [ message: "Doctest failed",
               expr: "inspect(#{unquote(String.strip(expr))}) === #{unquote(String.strip(expected))}",
               left: actual],
@@ -297,14 +297,14 @@ defmodule ExUnit.DocTest do
           unless error.__struct__ == unquote(exception) and
                  Exception.message(error) == unquote(message) do
             got = inspect(elem(error, 0)) <> " with message " <> inspect(Exception.message(error))
-            raise ExUnit.AssertionError,
+            reraise ExUnit.AssertionError,
               [message: "Doctest failed: expected exception #{spec} but got #{got}",
                expr: expr],
               stack
           end
       else
         _ ->
-          raise ExUnit.AssertionError,
+          reraise ExUnit.AssertionError,
             [message: "Doctest failed: expected exception #{spec} but nothing was raised",
              expr: expr],
             stack
@@ -326,7 +326,7 @@ defmodule ExUnit.DocTest do
       e ->
         message = "(#{inspect e.__struct__}) #{Exception.message(e)}"
         quote do
-          raise ExUnit.AssertionError,
+          reraise ExUnit.AssertionError,
             [message: "Doctest did not compile, got: #{unquote(message)}",
              expr: unquote(String.strip(expr))]
             unquote(stack)

lib/mix/lib/mix/cli.ex

@@ -83,7 +83,7 @@ defmodule Mix.CLI do
           end
           exit(1)
         else
-          raise exception, [], stacktrace
+          reraise exception, stacktrace
         end
     end
   end