Relax handling of __exception__

We were used to assert it to be true but,
given the value is not used in any shape,
we can relax the definition and simply assert
on the presence of the key.

Closes #15251.

Author: josevalim

lib/elixir/lib/exception.ex

@@ -26,7 +26,7 @@ defmodule Exception do
   @typedoc "The exception type"
   @type t :: %{
           required(:__struct__) => module,
-          required(:__exception__) => true,
+          required(:__exception__) => term,
           optional(atom) => any
         }
 
@@ -77,7 +77,7 @@ defmodule Exception do
   @doc false
   @deprecated "Use Kernel.is_exception/1 instead"
   def exception?(term)
-  def exception?(%_{__exception__: true}), do: true
+  def exception?(%_{__exception__: _}), do: true
   def exception?(_), do: false
 
   @doc """
@@ -89,7 +89,7 @@ defmodule Exception do
   return a descriptive error message instead.
   """
   @spec message(t) :: String.t()
-  def message(%module{__exception__: true} = exception) do
+  def message(%module{__exception__: _} = exception) do
     try do
       module.message(exception)
     rescue
@@ -123,7 +123,7 @@ defmodule Exception do
   @spec normalize(:error, any, stacktrace) :: t
   @spec normalize(non_error_kind, payload, stacktrace) :: payload when payload: var
   def normalize(kind, payload, stacktrace \\ [])
-  def normalize(:error, %_{__exception__: true} = payload, _stacktrace), do: payload
+  def normalize(:error, %_{__exception__: _} = payload, _stacktrace), do: payload
   def normalize(:error, payload, stacktrace), do: ErlangError.normalize(payload, stacktrace)
   def normalize(_kind, payload, _stacktrace), do: payload
 

lib/elixir/lib/kernel.ex

@@ -2752,7 +2752,7 @@ defmodule Kernel do
       nil ->
         quote do
           case unquote(term) do
-            %_{__exception__: true} -> true
+            %_{__exception__: _} -> true
             _ -> false
           end
         end
@@ -2764,8 +2764,7 @@ defmodule Kernel do
         quote do
           is_map(unquote(term)) and :erlang.is_map_key(:__struct__, unquote(term)) and
             is_atom(:erlang.map_get(:__struct__, unquote(term))) and
-            :erlang.is_map_key(:__exception__, unquote(term)) and
-            :erlang.map_get(:__exception__, unquote(term)) == true
+            :erlang.is_map_key(:__exception__, unquote(term))
         end
     end
   end
@@ -2792,7 +2791,7 @@ defmodule Kernel do
           case unquote(name) do
             name when is_atom(name) ->
               case unquote(term) do
-                %{__struct__: ^name, __exception__: true} -> true
+                %{__struct__: ^name, __exception__: _} -> true
                 _ -> false
               end
 
@@ -2810,8 +2809,7 @@ defmodule Kernel do
             (is_atom(unquote(name)) or :fail) and
             :erlang.is_map_key(:__struct__, unquote(term)) and
             :erlang.map_get(:__struct__, unquote(term)) == unquote(name) and
-            :erlang.is_map_key(:__exception__, unquote(term)) and
-            :erlang.map_get(:__exception__, unquote(term)) == true
+            :erlang.is_map_key(:__exception__, unquote(term))
         end
     end
   end

lib/elixir/lib/kernel/typespec.ex

@@ -610,8 +610,7 @@ defmodule Kernel.Typespec do
         types =
           :lists.map(
             fn %{field: field} ->
-              default_type = if field == :__exception__, do: true, else: quote(do: term())
-              {field, Keyword.get(fields, field, default_type)}
+              {field, Keyword.get(fields, field, quote(do: term()))}
             end,
             struct_info
           )

lib/elixir/lib/kernel/utils.ex

@@ -266,7 +266,7 @@ defmodule Kernel.Utils do
     module.exception([])
   end
 
-  def raise(%_{__exception__: true} = exception) do
+  def raise(%_{__exception__: _} = exception) do
     exception
   end
 

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

@@ -15,7 +15,6 @@ defmodule Module.Types.Expr do
   list_of_modules = list(atom())
 
   @try_catch atom([:error, :exit, :throw])
-  @atom_true atom([true])
 
   @caller closed_map(
             __struct__: atom([Macro.Env]),
@@ -41,7 +40,7 @@ defmodule Module.Types.Expr do
 
   # We do not make exception dynamic on purpose. If you do a blank rescue,
   # then we will assume you need to statically handle all possible exceptions.
-  @exception open_map(__struct__: atom(), __exception__: @atom_true)
+  @exception open_map(__struct__: atom(), __exception__: term())
 
   args_or_arity = union(list(term()), integer())
 
@@ -558,7 +557,7 @@ defmodule Module.Types.Expr do
   ## Try
 
   defp of_rescue(var, exceptions, body, expr, info, meta, stack, original) do
-    args = [__exception__: @atom_true]
+    args = [__exception__: term()]
 
     {structs, context} =
       Enum.map_reduce(exceptions, original, fn exception, context ->

lib/elixir/src/elixir_erl_try.erl

@@ -117,7 +117,7 @@ rescue_guards(Meta, Var, Aliases) ->
   ElixirGuards =
     [erl_and(Meta,
        {erl(Meta, '=='), Meta, [{erl(Meta, map_get), Meta, ['__struct__', Var]}, Alias]},
-       {erl(Meta, map_get), Meta, ['__exception__', Var]}
+       {erl(Meta, is_map_key), Meta, ['__exception__', Var]}
      ) || Alias <- Aliases],
 
   {ElixirGuards ++ ErlangGuards, ErlangAliases}.
@@ -214,7 +214,11 @@ erl_rescue_guard_for(Meta, Var, 'Elixir.ErlangError') ->
     erl_and(
       Meta,
       {erl(Meta, is_map), Meta, [Var]},
-      {erl(Meta, is_map_key), Meta, ['__exception__', Var]}
+      erl_and(
+        Meta,
+        {erl(Meta, is_map_key), Meta, ['__struct__', Var]},
+        {erl(Meta, is_map_key), Meta, ['__exception__', Var]}
+      )
     ),
   {erl(Meta, 'not'), Meta, [Condition]};
 

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

@@ -337,6 +337,22 @@ defmodule Kernel.RaiseTest do
       assert result == "Erlang error: :sample"
     end
 
+    test "runtime error from Erlang" do
+      result =
+        try do
+          :erlang.error(%{
+            __struct__: RuntimeError,
+            __exception__: :does_not_matter,
+            message: "oops"
+          })
+        rescue
+          x in [ErlangError] -> {:erlang, Exception.message(x)}
+          x in [RuntimeError] -> {:runtime, Exception.message(x)}
+        end
+
+      assert result == {:runtime, "oops"}
+    end
+
     test "undefined function error" do
       result =
         try do

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

@@ -2287,12 +2287,12 @@ defmodule Module.Types.ExprTest do
                  union(
                    closed_map(
                      __struct__: atom([ArgumentError]),
-                     __exception__: atom([true]),
+                     __exception__: term(),
                      message: term()
                    ),
                    closed_map(
                      __struct__: atom([RuntimeError]),
-                     __exception__: atom([true]),
+                     __exception__: term(),
                      message: term()
                    )
                  )
@@ -2309,7 +2309,7 @@ defmodule Module.Types.ExprTest do
              ) ==
                open_map(
                  __struct__: atom(),
-                 __exception__: atom([true])
+                 __exception__: term()
                )
     end
 
@@ -2328,15 +2328,15 @@ defmodule Module.Types.ExprTest do
 
              given types:
 
-                 %{..., __exception__: true, __struct__: atom()}
+                 %{..., __exception__: term(), __struct__: atom()}
 
              but expected one of:
 
                  integer()
 
              where "e" was given the type:
 
-                 # type: %{..., __exception__: true, __struct__: atom()}
+                 # type: %{..., __exception__: term(), __struct__: atom()}
                  # from: types_test.ex
                  rescue e
 

lib/elixir/test/elixir/typespec_test.exs

@@ -525,7 +525,10 @@ defmodule TypespecTest do
       assert {:type, _, :map, [struct, arg1, arg2]} = type
       assert {:type, _, :map_field_exact, struct_args} = struct
       assert [{:atom, _, :__struct__}, {:atom, _, TypespecSample}] = struct_args
-      assert {:type, _, :map_field_exact, [{:atom, _, :__exception__}, {:atom, _, true}]} = arg1
+
+      assert {:type, _, :map_field_exact, [{:atom, _, :__exception__}, {:type, _, :term, []}]} =
+               arg1
+
       assert {:type, _, :map_field_exact, [{:atom, _, :message}, {:type, _, :term, []}]} = arg2
     end