Type checking of stacktrace and error/raise functions

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -2217,28 +2217,22 @@ defmodule Kernel do
     case Macro.expand(message, __CALLER__) do
       message when is_binary(message) ->
         quote do
-          :erlang.error(
-            :erlang.raise(:error, RuntimeError.exception(unquote(message)), unquote(stacktrace))
-          )
+          :erlang.raise(:error, RuntimeError.exception(unquote(message)), unquote(stacktrace))
         end
 
       {:<<>>, _, _} = message ->
         quote do
-          :erlang.error(
-            :erlang.raise(:error, RuntimeError.exception(unquote(message)), unquote(stacktrace))
-          )
+          :erlang.raise(:error, RuntimeError.exception(unquote(message)), unquote(stacktrace))
         end
 
       alias when is_atom(alias) ->
         quote do
-          :erlang.error(:erlang.raise(:error, unquote(alias).exception([]), unquote(stacktrace)))
+          :erlang.raise(:error, unquote(alias).exception([]), unquote(stacktrace))
         end
 
       message ->
         quote do
-          :erlang.error(
-            :erlang.raise(:error, Kernel.Utils.raise(unquote(message)), unquote(stacktrace))
-          )
+          :erlang.raise(:error, Kernel.Utils.raise(unquote(message)), unquote(stacktrace))
         end
     end
   end

lib/elixir/lib/module/types/expr.ex

@@ -110,7 +110,12 @@ defmodule Module.Types.Expr do
   # left = right
   def of_expr({:=, _meta, [left_expr, right_expr]} = expr, stack, context) do
     {right_type, context} = of_expr(right_expr, stack, context)
-    Pattern.of_match(left_expr, right_type, expr, stack, context)
+
+    # We do not raise on underscore in case someone writes _ = raise "omg"
+    case left_expr do
+      {:_, _, ctx} when is_atom(ctx) -> {right_type, context}
+      _ -> Pattern.of_match(left_expr, right_type, expr, stack, context)
+    end
   end
 
   # %{map | ...}

lib/elixir/lib/module/types/of.ex

@@ -365,6 +365,28 @@ defmodule Module.Types.Of do
 
   is_clauses = [{[term()], boolean()}]
 
+  args_or_arity = union(list(term()), integer())
+  args_or_none = union(list(term()), atom([:none]))
+
+  kw = fn kw ->
+    kw
+    |> Enum.map(fn {key, type} when is_atom(key) ->
+      tuple([atom([key]), type])
+    end)
+    |> Enum.reduce(&union/2)
+    |> list()
+  end
+
+  extra_info = kw.(file: list(integer()), line: integer(), error_info: open_map())
+
+  raise_stacktrace =
+    list(
+      tuple([atom(), atom(), args_or_arity, extra_info])
+      |> union(tuple([atom(), atom(), args_or_arity]))
+      |> union(tuple([fun(), args_or_arity, extra_info]))
+      |> union(tuple([fun(), args_or_arity]))
+    )
+
   for {mod, fun, clauses} <- [
         # :binary
         {:binary, :copy, [{[binary(), integer()], binary()}]},
@@ -403,6 +425,9 @@ defmodule Module.Types.Of do
         {:erlang, :byte_size, [{[binary()], integer()}]},
         {:erlang, :ceil, [{[union(integer(), float())], integer()}]},
         {:erlang, :div, [{[integer(), integer()], integer()}]},
+        {:erlang, :error, [{[term()], none()}]},
+        {:erlang, :error, [{[term(), args_or_none], none()}]},
+        {:erlang, :error, [{[term(), args_or_none, kw.(error_info: open_map())], none()}]},
         {:erlang, :floor, [{[union(integer(), float())], integer()}]},
         {:erlang, :function_exported, [{[atom(), atom(), integer()], boolean()}]},
         {:erlang, :integer_to_binary, [{[integer()], binary()}]},
@@ -437,6 +462,7 @@ defmodule Module.Types.Of do
         {:erlang, :node, [{[], atom()}]},
         {:erlang, :node, [{[pid() |> union(reference()) |> union(port())], atom()}]},
         {:erlang, :not, [{[atom([false])], atom([true])}, {[atom([true])], atom([false])}]},
+        {:erlang, :raise, [{[atom([:error, :exit, :throw]), term(), raise_stacktrace], none()}]},
         {:erlang, :rem, [{[integer(), integer()], integer()}]},
         {:erlang, :round, [{[union(integer(), float())], integer()}]},
         {:erlang, :self, [{[], pid()}]},

lib/elixir/test/elixir/kernel/raise_test.exs

@@ -163,16 +163,6 @@ defmodule Kernel.RaiseTest do
     end
   end
 
-  test "reraise with invalid stacktrace" do
-    try do
-      reraise %RuntimeError{message: "message"}, {:oops, @trace}
-    rescue
-      ArgumentError ->
-        {name, arity} = __ENV__.function
-        assert [{__MODULE__, ^name, ^arity, _} | _] = __STACKTRACE__
-    end
-  end
-
   describe "rescue" do
     test "runtime error" do
       result =

lib/elixir/test/elixir/module/types/pattern_test.exs

@@ -69,7 +69,7 @@ defmodule Module.Types.PatternTest do
                """
     end
 
-    test "can be access even if they don't match" do
+    test "can be accessed even if they don't match" do
       assert typeerror!(
                (
                  # This will never match, info should not be "corrupted"
@@ -78,6 +78,10 @@ defmodule Module.Types.PatternTest do
                )
              ) =~ "incompatible types in expression"
     end
+
+    test "does not check underscore" do
+      assert typecheck!(_ = raise("oops")) == none()
+    end
   end
 
   describe "structs" do