Type checking of try

Author: josevalim

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

@@ -241,46 +241,51 @@ defmodule Module.Types.Expr do
     |> dynamic_unless_static(stack)
   end
 
-  # TODO: case expr do pat -> expr end
   def of_expr({:case, _meta, [case_expr, [{:do, clauses}]]}, stack, context) do
-    {_expr_type, context} = of_expr(case_expr, stack, context)
+    {expr_type, context} = of_expr(case_expr, stack, context)
 
     clauses
-    |> of_clauses(stack, {none(), context})
+    |> of_clauses(stack, [expr_type], {none(), context})
     |> dynamic_unless_static(stack)
   end
 
   # TODO: fn pat -> expr end
   def of_expr({:fn, _meta, clauses}, stack, context) do
-    {_acc, context} = of_clauses(clauses, stack, {none(), context})
+    [{:->, _, [args, _]} | _] = clauses
+    expected = Enum.map(args, fn _ -> dynamic() end)
+    {_acc, context} = of_clauses(clauses, stack, expected, {none(), context})
     {fun(), context}
   end
 
-  @try_blocks [:do, :after]
-  @try_clause_blocks [:catch, :else]
+  def of_expr({:try, _meta, [[do: body] ++ blocks]}, stack, context) do
+    {body_type, context} = of_expr(body, stack, context)
+    initial = if Keyword.has_key?(blocks, :else), do: none(), else: body_type
 
-  # TODO: try do expr end
-  def of_expr({:try, _meta, [blocks]}, stack, context) do
-    context =
-      Enum.reduce(blocks, context, fn
-        {:rescue, clauses}, context ->
-          Enum.reduce(clauses, context, fn
-            {:->, _, [[{:in, meta, [var, exceptions]} = expr], body]}, context ->
-              of_rescue(var, exceptions, body, expr, [], meta, stack, context)
-
-            {:->, meta, [[var], body]}, context ->
-              of_rescue(var, [], body, var, [:anonymous_rescue], meta, stack, context)
-          end)
+    blocks
+    |> Enum.reduce({initial, context}, fn
+      {:rescue, clauses}, acc_context ->
+        Enum.reduce(clauses, acc_context, fn
+          {:->, _, [[{:in, meta, [var, exceptions]} = expr], body]}, {acc, context} ->
+            {type, context} = of_rescue(var, exceptions, body, expr, [], meta, stack, context)
+            {union(type, acc), context}
+
+          {:->, meta, [[var], body]}, {acc, context} ->
+            hint = [:anonymous_rescue]
+            {type, context} = of_rescue(var, [], body, var, hint, meta, stack, context)
+            {union(type, acc), context}
+        end)
 
-        {block, body}, context when block in @try_blocks ->
-          of_expr_context(body, stack, context)
+      {:after, body}, {acc, context} ->
+        {_type, context} = of_expr(body, stack, context)
+        {acc, context}
 
-        {block, clauses}, context when block in @try_clause_blocks ->
-          {_, context} = of_clauses(clauses, stack, {none(), context})
-          context
-      end)
+      {:catch, clauses}, acc_context ->
+        of_clauses(clauses, stack, [atom([:error, :exit, :throw]), dynamic()], acc_context)
 
-    {dynamic(), context}
+      {:else, clauses}, acc_context ->
+        of_clauses(clauses, stack, [body_type], acc_context)
+    end)
+    |> dynamic_unless_static(stack)
   end
 
   def of_expr({:receive, _meta, [blocks]}, stack, context) do
@@ -290,7 +295,7 @@ defmodule Module.Types.Expr do
         {acc, context}
 
       {:do, clauses}, {acc, context} ->
-        of_clauses(clauses, stack, {acc, context})
+        of_clauses(clauses, stack, [dynamic()], {acc, context})
 
       {:after, [{:->, meta, [[timeout], body]}]}, {acc, context} ->
         {timeout_type, context} = of_expr(timeout, stack, context)
@@ -313,7 +318,7 @@ defmodule Module.Types.Expr do
     context = Enum.reduce(opts, context, &for_option(&1, stack, &2))
 
     if Keyword.has_key?(opts, :reduce) do
-      {_, context} = of_clauses(block, stack, {none(), context})
+      {_, context} = of_clauses(block, stack, [dynamic()], {none(), context})
       {dynamic(), context}
     else
       {_type, context} = of_expr(block, stack, context)
@@ -431,7 +436,7 @@ defmodule Module.Types.Expr do
           context
       end
 
-    of_expr_context(body, stack, context)
+    of_expr(body, stack, context)
   end
 
   ## Comprehensions
@@ -456,15 +461,18 @@ defmodule Module.Types.Expr do
   end
 
   defp for_clause(expr, stack, context) do
-    of_expr_context(expr, stack, context)
+    {_type, context} = of_expr(expr, stack, context)
+    context
   end
 
   defp for_option({:into, expr}, stack, context) do
-    of_expr_context(expr, stack, context)
+    {_type, context} = of_expr(expr, stack, context)
+    context
   end
 
   defp for_option({:reduce, expr}, stack, context) do
-    of_expr_context(expr, stack, context)
+    {_type, context} = of_expr(expr, stack, context)
+    context
   end
 
   defp for_option({:uniq, _}, _stack, context) do
@@ -482,15 +490,17 @@ defmodule Module.Types.Expr do
   end
 
   defp with_clause(expr, stack, context) do
-    of_expr_context(expr, stack, context)
+    {_type, context} = of_expr(expr, stack, context)
+    context
   end
 
   defp with_option({:do, body}, stack, context) do
-    of_expr_context(body, stack, context)
+    {_type, context} = of_expr(body, stack, context)
+    context
   end
 
   defp with_option({:else, clauses}, stack, context) do
-    {_, context} = of_clauses(clauses, stack, {none(), context})
+    {_, context} = of_clauses(clauses, stack, [dynamic()], {none(), context})
     context
   end
 
@@ -522,7 +532,7 @@ defmodule Module.Types.Expr do
   defp dynamic_unless_static({_, _} = output, %{mode: :static}), do: output
   defp dynamic_unless_static({type, context}, %{mode: _}), do: {dynamic(type), context}
 
-  defp of_clauses(clauses, stack, acc_context) do
+  defp of_clauses(clauses, stack, _expected, acc_context) do
     Enum.reduce(clauses, acc_context, fn {:->, meta, [head, body]}, {acc, context} ->
       {patterns, guards} = extract_head(head)
       {_types, context} = Pattern.of_head(patterns, guards, meta, stack, context)
@@ -545,11 +555,6 @@ defmodule Module.Types.Expr do
   defp flatten_when({:when, _meta, [left, right]}), do: [left | flatten_when(right)]
   defp flatten_when(other), do: [other]
 
-  defp of_expr_context(expr, stack, context) do
-    {_type, context} = of_expr(expr, stack, context)
-    context
-  end
-
   defp map_put!(map_type, key, value_type) do
     case map_put(map_type, key, value_type) do
       {:ok, descr} -> descr

lib/elixir/src/elixir_clauses.erl

@@ -197,12 +197,15 @@ clause(Meta, Kind, _Fun, _, _, E) ->
 
 head(Meta, [{'when', WhenMeta, [_ | _] = All}], S, E) ->
   {Args, Guard} = elixir_utils:split_last(All),
-  {EArgs, SA, EA} = match(fun elixir_expand:expand_args/3, Meta, Args, S, S, E),
-  {EGuard, SG, EG} = guard(Guard, SA, EA#{context := guard}),
-  {[{'when', WhenMeta, EArgs ++ [EGuard]}], SG, EG#{context := nil}};
+  guarded_head(Meta, WhenMeta, Args, Guard, S, E);
 head(Meta, Args, S, E) ->
   match(fun elixir_expand:expand_args/3, Meta, Args, S, S, E).
 
+guarded_head(Meta, WhenMeta, Args, Guard, S, E) ->
+  {EArgs, SA, EA} = match(fun elixir_expand:expand_args/3, Meta, Args, S, S, E),
+  {EGuard, SG, EG} = guard(Guard, SA, EA#{context := guard}),
+  {[{'when', WhenMeta, EArgs ++ [EGuard]}], SG, EG#{context := nil}}.
+
 guard({'when', Meta, [Left, Right]}, S, E) ->
   {ELeft, SL, EL}  = guard(Left, S, E),
   {ERight, SR, ER} = guard(Right, SL, EL),
@@ -400,8 +403,12 @@ expand_clauses_with_stacktrace(Meta, Fun, Clauses, S, E) ->
 expand_catch(Meta, [{'when', _, [_, _, _, _ | _]}], _, E) ->
   Error = {wrong_number_of_args_for_clause, "one or two args", origin(Meta, 'try'), 'catch'},
   file_error(Meta, E, ?MODULE, Error);
-expand_catch(Meta, [_] = Args, S, E) ->
-  head(Meta, Args, S, E);
+expand_catch(Meta, [{'when', WhenMeta, [Arg1, Arg2, Guard]}], S, E) ->
+  guarded_head(Meta, WhenMeta, [Arg1, Arg2], Guard, S, E);
+expand_catch(Meta, [{'when', WhenMeta, [Arg1, Guard]}], S, E) ->
+  guarded_head(Meta, WhenMeta, [Arg1], Guard, S, E);
+expand_catch(Meta, [Arg], S, E) ->
+  head(Meta, [throw, Arg], S, E);
 expand_catch(Meta, [_, _] = Args, S, E) ->
   head(Meta, Args, S, E);
 expand_catch(Meta, _, _, E) ->

lib/elixir/src/elixir_erl_try.erl

@@ -20,13 +20,7 @@ reduce_clauses([], Acc, OldStack, SAcc, _S) ->
   {lists:reverse(Acc), SAcc#elixir_erl{stacktrace=OldStack}}.
 
 each_clause({'catch', Meta, Raw, Expr}, S) ->
-  {Args, Guards} = elixir_utils:extract_splat_guards(Raw),
-
-  Match =
-    case Args of
-      [X] -> [throw, X];
-      [X, Y] -> [X, Y]
-    end,
+  {Match, Guards} = elixir_utils:extract_splat_guards(Raw),
 
   {{clause, Line, [TKind, TMatches], TGuards, TBody}, TS} =
     elixir_erl_clauses:clause(?ann(Meta), fun elixir_erl_pass:translate_args/3, Match, Expr, Guards, S),

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

@@ -147,7 +147,7 @@ defmodule Module.Types.ExprTest do
                {dynamic() |> union(atom([nil])), "URI.unknown/1 is undefined or private"}
 
       assert typewarn!(try(do: :ok, after: URI.unknown("foo"))) ==
-               {dynamic(), "URI.unknown/1 is undefined or private"}
+               {atom([:ok]), "URI.unknown/1 is undefined or private"}
 
       # Check it also emits over a union
       assert typewarn!(
@@ -1063,6 +1063,38 @@ defmodule Module.Types.ExprTest do
   end
 
   describe "try" do
+    test "returns unions of all clauses" do
+      assert typecheck!(
+               try do
+                 :do
+               rescue
+                 _ -> :rescue
+               catch
+                 :caught -> :caught1
+                 :throw, :caught -> :caught2
+               after
+                 :not_used
+               end
+             ) == atom([:do, :caught1, :caught2, :rescue])
+
+      assert typecheck!(
+               [x],
+               try do
+                 x
+               rescue
+                 _ -> :rescue
+               catch
+                 :caught -> :caught1
+                 :throw, :caught -> :caught2
+               after
+                 :not_used
+               else
+                 :match -> :else1
+                 _ -> :else2
+               end
+             ) == atom([:caught1, :caught2, :rescue, :else1, :else2])
+    end
+
     test "warns on undefined exceptions" do
       assert typewarn!(
                try do
@@ -1071,7 +1103,7 @@ defmodule Module.Types.ExprTest do
                  e in UnknownError -> e
                end
              ) ==
-               {dynamic(),
+               {dynamic() |> union(atom([:ok])),
                 "struct UnknownError is undefined (module UnknownError is not available or is yet to be defined). " <>
                   "Make sure the module name is correct and has been specified in full (or that an alias has been defined)"}
 
@@ -1082,67 +1114,48 @@ defmodule Module.Types.ExprTest do
                  e in Enumerable -> e
                end
              ) ==
-               {dynamic(),
+               {dynamic() |> union(atom([:ok])),
                 "struct Enumerable is undefined (there is such module but it does not define a struct)"}
     end
 
     test "defines unions of exceptions in rescue" do
-      # TODO: we are validating the type through the exception but we should actually check the returned type
-      assert typeerror!(
+      assert typecheck!(
                try do
-                 :ok
+                 raise "oops"
                rescue
-                 e in [SyntaxError, RuntimeError] ->
-                   e.unknown
+                 e in [RuntimeError, ArgumentError] ->
+                   e
                end
              ) ==
-               ~l"""
-               unknown key .unknown in expression:
-
-                   e.unknown
-
-               where "e" was given the type:
-
-                   # type: %RuntimeError{__exception__: true, message: term()} or
-                     %SyntaxError{
-                       __exception__: true,
-                       column: term(),
-                       description: term(),
-                       file: term(),
-                       line: term(),
-                       snippet: term()
-                     }
-                   # from: types_test.ex:LINE-4
-                   rescue e in [SyntaxError, RuntimeError] ->
-               """
+               union(
+                 closed_map(
+                   __struct__: atom([ArgumentError]),
+                   __exception__: atom([true]),
+                   message: term()
+                 ),
+                 closed_map(
+                   __struct__: atom([RuntimeError]),
+                   __exception__: atom([true]),
+                   message: term()
+                 )
+               )
     end
 
     test "defines an open map of two fields in anonymous rescue" do
-      # TODO: we are validating the type through the exception but we should actually check the returned type
-      assert typeerror!(
+      assert typecheck!(
                try do
-                 :ok
+                 raise "oops"
                rescue
-                 e -> e.message
+                 e -> e
                end
              ) ==
-               ~l"""
-               unknown key .message in expression:
-
-                   e.message
-
-               where "e" was given the type:
-
-                   # type: %{..., __exception__: true, __struct__: atom()}
-                   # from: types_test.ex:LINE-3
-                   rescue e ->
-
-               #{hints(:anonymous_rescue)}
-               """
+               open_map(
+                 __struct__: atom(),
+                 __exception__: atom([true])
+               )
     end
 
     test "matches on stacktrace" do
-      # TODO: we are validating the type through the exception but we should actually check the returned type
       assert typeerror!(
                try do
                  :ok