Convert more expressions back into their original calls

Author: josevalim

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

@@ -325,12 +325,15 @@ defmodule Module.Types.Expr do
         {: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)
+              {type, context} =
+                of_rescue(var, exceptions, body, expr, :rescue, 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)
+              {type, context} =
+                of_rescue(var, [], body, var, :anonymous_rescue, meta, stack, context)
+
               {union(type, acc), context}
           end)
 
@@ -532,7 +535,7 @@ defmodule Module.Types.Expr do
 
   ## Try
 
-  defp of_rescue(var, exceptions, body, expr, hints, meta, stack, original) do
+  defp of_rescue(var, exceptions, body, expr, info, meta, stack, original) do
     args = [__exception__: @atom_true]
 
     {structs, context} =
@@ -557,11 +560,8 @@ defmodule Module.Types.Expr do
 
         _ ->
           expected = if structs == [], do: @exception, else: Enum.reduce(structs, &union/2)
-          formatter = fn expr -> {"rescue #{expr_to_string(expr)} ->", hints} end
-
-          {_ok?, _type, context} =
-            Of.refine_head_var(var, expected, expr, formatter, stack, context)
-
+          expr = {:__block__, [type_check: info], [expr]}
+          {_ok?, _type, context} = Of.refine_head_var(var, expected, expr, stack, context)
           context
       end
 
@@ -695,9 +695,10 @@ defmodule Module.Types.Expr do
     apply_one(mod, fun, args, expected, expr, stack, context)
   end
 
-  defp apply_many(mods, fun, args, expected, expr, stack, context) do
+  defp apply_many(mods, fun, args, expected, {remote, meta, args}, stack, context) do
     {returns, context} =
       Enum.map_reduce(mods, context, fn mod, context ->
+        expr = {remote, [type_check: {:invoked_as, mod, fun, length(args)}] ++ meta, args}
         apply_one(mod, fun, args, expected, expr, stack, context)
       end)
 

lib/elixir/lib/module/types/helpers.ex

@@ -137,7 +137,7 @@ defmodule Module.Types.Helpers do
                  type: :variable,
                  name: name,
                  context: context,
-                 traces: collect_var_traces(off_traces)
+                 traces: collect_var_traces(expr, off_traces)
                })}
 
             _ ->
@@ -153,40 +153,50 @@ defmodule Module.Types.Helpers do
     |> Enum.sort_by(& &1.name)
   end
 
-  defp collect_var_traces(traces) do
+  defp collect_var_traces(parent_expr, traces) do
     traces
-    |> Enum.reject(fn {_expr, _file, type, _formatter} ->
+    |> Enum.reject(fn {expr, _file, type} ->
       # As an otimization do not care about dynamic terms
-      type == %{dynamic: :term}
+      type == %{dynamic: :term} or expr == parent_expr
     end)
     |> case do
       [] -> traces
       filtered -> filtered
     end
     |> Enum.reverse()
-    |> Enum.map(fn {expr, file, type, formatter} ->
+    |> Enum.map(fn {expr, file, type} ->
       meta = get_meta(expr)
 
-      {formatted_expr, formatter_hints} =
-        case formatter do
-          :default -> {expr_to_string(expr), []}
-          formatter -> formatter.(expr)
-        end
-
       # This information is exposed to language servers and
       # therefore must remain backwards compatible.
       %{
         file: file,
         meta: meta,
-        formatted_expr: formatted_expr,
-        formatted_hints: format_hints(formatter_hints ++ expr_hints(expr)),
+        formatted_expr: expr_to_string(expr),
+        formatted_hints: format_hints(expr_hints(expr)),
         formatted_type: Module.Types.Descr.to_quoted_string(type, collapse_structs: true)
       }
     end)
     |> Enum.sort_by(&{&1.meta[:line], &1.meta[:column]})
     |> Enum.dedup()
   end
 
+  defp expr_hints(expr) do
+    case expr do
+      {:<<>>, [inferred_bitstring_spec: true] ++ _meta, _} ->
+        [:inferred_bitstring_spec]
+
+      {_, meta, _} ->
+        case meta[:type_check] do
+          :anonymous_rescue -> [:anonymous_rescue]
+          _ -> []
+        end
+
+      _ ->
+        []
+    end
+  end
+
   @doc """
   Format previously collected traces.
   """
@@ -230,18 +240,37 @@ defmodule Module.Types.Helpers do
   defp pluralize([_], singular, _plural), do: singular
   defp pluralize(_, _singular, plural), do: plural
 
-  defp expr_hints({:<<>>, [inferred_bitstring_spec: true] ++ _meta, _}),
-    do: [:inferred_bitstring_spec]
-
-  defp expr_hints(_), do: []
-
   @doc """
   Converts the given expression to a string,
   translating inlined Erlang calls back to Elixir.
 
   We also undo some macro expressions done by the Kernel module.
   """
   def expr_to_string(expr) do
+    string = prewalk_expr_to_string(expr)
+
+    case expr do
+      {_, meta, _} ->
+        case meta[:type_check] do
+          :anonymous_rescue ->
+            "rescue " <> string
+
+          :rescue ->
+            "rescue " <> string
+
+          {:invoked_as, mod, fun, arity} ->
+            string <> "\n#=> invoked as " <> Exception.format_mfa(mod, fun, arity)
+
+          _ ->
+            string
+        end
+
+      _ ->
+        string
+    end
+  end
+
+  defp prewalk_expr_to_string(expr) do
     expr
     |> Macro.prewalk(fn
       {:%, _, [Range, {:%{}, _, fields}]} = node ->
@@ -264,6 +293,42 @@ defmodule Module.Types.Helpers do
       {{:., _, [mod, fun]}, meta, args} ->
         erl_to_ex(mod, fun, args, meta)
 
+      {:case, meta, [expr, [do: clauses]]} = case ->
+        if meta[:type_check] == :expr do
+          case clauses do
+            [
+              {:->, _,
+               [
+                 [
+                   {:when, _,
+                    [
+                      {var, _, Kernel},
+                      {{:., _, [:erlang, :orelse]}, _,
+                       [
+                         {{:., _, [:erlang, :"=:="]}, _, [{var, _, Kernel}, false]},
+                         {{:., _, [:erlang, :"=:="]}, _, [{var, _, Kernel}, nil]}
+                       ]}
+                    ]}
+                 ],
+                 else_block
+               ]},
+              {:->, _, [[{:_, _, Kernel}], do_block]}
+            ] ->
+              {:if, meta, [expr, [do: do_block, else: else_block]]}
+
+            [
+              {:->, _, [[false], else_block]},
+              {:->, _, [[true], do_block]}
+            ] ->
+              {:if, meta, [expr, [do: do_block, else: else_block]]}
+
+            _ ->
+              case
+          end
+        else
+          case
+        end
+
       other ->
         other
     end)

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

@@ -59,7 +59,7 @@ defmodule Module.Types.Of do
             data = %{
               data
               | type: new_type,
-                off_traces: new_trace(expr, new_type, :default, stack, off_traces)
+                off_traces: new_trace(expr, new_type, stack, off_traces)
             }
 
             %{context | vars: %{vars | version => data}}
@@ -81,7 +81,7 @@ defmodule Module.Types.Of do
   because we want to refine types. Otherwise we should
   use compatibility.
   """
-  def refine_head_var(var, type, expr, formatter \\ :default, stack, context) do
+  def refine_head_var(var, type, expr, stack, context) do
     {var_name, meta, var_context} = var
     version = Keyword.fetch!(meta, :version)
 
@@ -92,7 +92,7 @@ defmodule Module.Types.Of do
         data = %{
           data
           | type: new_type,
-            off_traces: new_trace(expr, type, formatter, stack, off_traces)
+            off_traces: new_trace(expr, type, stack, off_traces)
         }
 
         context = %{context | vars: %{vars | version => data}}
@@ -110,19 +110,19 @@ defmodule Module.Types.Of do
           type: type,
           name: var_name,
           context: var_context,
-          off_traces: new_trace(expr, type, formatter, stack, [])
+          off_traces: new_trace(expr, type, stack, [])
         }
 
         context = %{context | vars: Map.put(vars, version, data)}
         {:ok, type, context}
     end
   end
 
-  defp new_trace(nil, _type, _formatter, _stack, traces),
+  defp new_trace(nil, _type, _stack, traces),
     do: traces
 
-  defp new_trace(expr, type, formatter, stack, traces),
-    do: [{expr, stack.file, type, formatter} | traces]
+  defp new_trace(expr, type, stack, traces),
+    do: [{expr, stack.file, type} | traces]
 
   ## Implementations