Fix clause rewriting in typing violations on apply

Author: josevalim

lib/elixir/lib/exception.ex

@@ -407,8 +407,8 @@ defmodule Exception do
 
   defp erl_to_ex(mod, fun, args, meta) do
     case :elixir_rewrite.erl_to_ex(mod, fun, args) do
-      {Kernel, fun, args} -> {fun, meta, args}
-      {mod, fun, args} -> {{:., [], [mod, fun]}, meta, args}
+      {Kernel, fun, args, _} -> {fun, meta, args}
+      {mod, fun, args, _} -> {{:., [], [mod, fun]}, meta, args}
     end
   end
 

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

@@ -195,21 +195,17 @@ defmodule Module.Types.Helpers do
   """
   def expr_to_string(expr) do
     expr
-    |> reverse_rewrite()
-    |> Macro.to_string()
-  end
-
-  defp reverse_rewrite(guard) do
-    Macro.prewalk(guard, fn
+    |> Macro.prewalk(fn
       {{:., _, [mod, fun]}, meta, args} -> erl_to_ex(mod, fun, args, meta)
       other -> other
     end)
+    |> Macro.to_string()
   end
 
   defp erl_to_ex(mod, fun, args, meta) do
     case :elixir_rewrite.erl_to_ex(mod, fun, args) do
-      {Kernel, fun, args} -> {fun, meta, args}
-      {mod, fun, args} -> {{:., [], [mod, fun]}, meta, args}
+      {Kernel, fun, args, _} -> {fun, meta, args}
+      {mod, fun, args, _} -> {{:., [], [mod, fun]}, meta, args}
     end
   end
 

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

@@ -931,21 +931,23 @@ defmodule Module.Types.Of do
     traces = collect_traces(expr, context)
     {{:., _, [mod, fun]}, _, args} = expr
 
+    {mod, fun, args, converter} = :elixir_rewrite.erl_to_ex(mod, fun, args)
+
     %{
       details: %{typing_traces: traces},
       message:
         IO.iodata_to_binary([
           """
-          incompatible types given to #{format_mfa(mod, fun, args)}:
+          incompatible types given to #{Exception.format_mfa(mod, fun, length(args))}:
 
               #{expr_to_string(expr) |> indent(4)}
 
           given types:
 
-              #{args_to_quoted_string(mod, fun, args_types, domain) |> indent(4)}
+              #{args_to_quoted_string(args_types, domain, converter) |> indent(4)}
 
           but expected one of:
-          #{clauses_args_to_quoted_string(mod, fun, clauses)}
+          #{clauses_args_to_quoted_string(clauses, converter)}
           """,
           format_traces(traces)
         ])
@@ -1082,41 +1084,37 @@ defmodule Module.Types.Of do
   end
 
   defp format_mfa({{:., _, [mod, fun]}, _, args}) do
-    format_mfa(mod, fun, args)
-  end
-
-  defp format_mfa(mod, fun, args) do
-    {mod, fun, args} = :elixir_rewrite.erl_to_ex(mod, fun, args)
+    {mod, fun, args, _} = :elixir_rewrite.erl_to_ex(mod, fun, args)
     Exception.format_mfa(mod, fun, length(args))
   end
 
   ## Algebra helpers
 
   alias Inspect.Algebra, as: IA
 
-  defp clauses_args_to_quoted_string(mod, fun, [{args, _return}]) do
-    "\n    " <> (clause_args_to_quoted_string(mod, fun, args) |> indent(4))
+  defp clauses_args_to_quoted_string([{args, _return}], converter) do
+    "\n    " <> (clause_args_to_quoted_string(args, converter) |> indent(4))
   end
 
-  defp clauses_args_to_quoted_string(mod, fun, clauses) do
+  defp clauses_args_to_quoted_string(clauses, converter) do
     clauses
     |> Enum.with_index(fn {args, _return}, index ->
       """
 
       ##{index + 1}
-      #{clause_args_to_quoted_string(mod, fun, args)}\
+      #{clause_args_to_quoted_string(args, converter)}\
       """
       |> indent(4)
     end)
     |> Enum.join("\n")
   end
 
-  defp clause_args_to_quoted_string(mod, fun, args) do
+  defp clause_args_to_quoted_string(args, converter) do
     docs = Enum.map(args, &(&1 |> to_quoted() |> Code.Formatter.to_algebra()))
-    args_docs_to_quoted_string(mod, fun, docs)
+    args_docs_to_quoted_string(converter.(docs))
   end
 
-  defp args_to_quoted_string(mod, fun, args_types, domain) do
+  defp args_to_quoted_string(args_types, domain, converter) do
     ansi? = IO.ANSI.enabled?()
 
     docs =
@@ -1130,11 +1128,10 @@ defmodule Module.Types.Of do
         end
       end)
 
-    args_docs_to_quoted_string(mod, fun, docs)
+    args_docs_to_quoted_string(converter.(docs))
   end
 
-  defp args_docs_to_quoted_string(mod, fun, docs) do
-    {_mod, _fun, docs} = :elixir_rewrite.erl_to_ex(mod, fun, docs)
+  defp args_docs_to_quoted_string(docs) do
     doc = IA.fold(docs, fn doc, acc -> IA.glue(IA.concat(doc, ","), acc) end)
 
     wrapped_docs =

lib/elixir/src/elixir_rewrite.erl

@@ -1,5 +1,6 @@
 -module(elixir_rewrite).
 -compile({inline, [inner_inline/4, inner_rewrite/5]}).
+-compile(nowarn_shadow_vars).
 -export([erl_to_ex/3, inline/3, rewrite/5, match/6, guard/6, format_error/1]).
 -include("elixir.hrl").
 
@@ -36,13 +37,13 @@
 -define(
   rewrite(ExMod, ExFun, ExArgs, ErlMod, ErlFun, ErlArgs),
   inner_rewrite(ex_to_erl, _Meta, ExMod, ExFun, ExArgs) -> {ErlMod, ErlFun, ErlArgs};
-  inner_rewrite(erl_to_ex, _Meta, ErlMod, ErlFun, ErlArgs) -> {ExMod, ExFun, ExArgs}
+  inner_rewrite(erl_to_ex, _Meta, ErlMod, ErlFun, ErlArgs) -> {ExMod, ExFun, ExArgs, fun(ErlArgs) -> ExArgs end}
 ).
 
 erl_to_ex(Mod, Fun, Args) ->
   case inner_inline(erl_to_ex, Mod, Fun, length(Args)) of
     false -> inner_rewrite(erl_to_ex, [], Mod, Fun, Args);
-    {ExMod, ExFun} -> {ExMod, ExFun, Args}
+    {ExMod, ExFun} -> {ExMod, ExFun, Args, fun identity/1}
   end.
 
 %% Inline  rules
@@ -270,29 +271,32 @@ inner_rewrite(ex_to_erl, Meta, ?kernel, put_elem, [Tuple, Index, Value]) ->
   {erlang, setelement, [increment(Meta, Index), Tuple, Value]};
 
 inner_rewrite(erl_to_ex, _Meta, erlang, delete_element, [Index, Tuple]) when is_number(Index) ->
-  {?tuple, delete_at, [Tuple, Index - 1]};
+  {?tuple, delete_at, [Tuple, Index - 1], fun([Index, Tuple]) -> [Tuple, Index] end};
 inner_rewrite(erl_to_ex, _Meta, erlang, insert_element, [Index, Tuple, Term]) when is_number(Index) ->
-  {?tuple, insert_at, [Tuple, Index - 1, Term]};
+  {?tuple, insert_at, [Tuple, Index - 1, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};
 inner_rewrite(erl_to_ex, _Meta, erlang, element, [Index, Tuple]) when is_number(Index) ->
-  {?kernel, elem, [Tuple, Index - 1]};
-inner_rewrite(erl_to_ex, _Meta, erlang, setelement, [Index, Tuple, Value]) when is_number(Index) ->
-  {?kernel, put_elem, [Tuple, Index - 1, Value]};
+  {?kernel, elem, [Tuple, Index - 1], fun([Index, Tuple]) -> [Tuple, Index] end};
+inner_rewrite(erl_to_ex, _Meta, erlang, setelement, [Index, Tuple, Term]) when is_number(Index) ->
+  {?kernel, put_elem, [Tuple, Index - 1, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};
 
 inner_rewrite(erl_to_ex, _Meta, erlang, delete_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->
-  {?tuple, delete_at, [Tuple, Index]};
+  {?tuple, delete_at, [Tuple, Index], fun([Index, Tuple]) -> [Tuple, Index] end};
 inner_rewrite(erl_to_ex, _Meta, erlang, insert_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Term]) ->
-  {?tuple, insert_at, [Tuple, Index, Term]};
+  {?tuple, insert_at, [Tuple, Index, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};
 inner_rewrite(erl_to_ex, _Meta, erlang, element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->
-  {?kernel, elem, [Tuple, Index]};
-inner_rewrite(erl_to_ex, _Meta, erlang, setelement, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Value]) ->
-  {?kernel, put_elem, [Tuple, Index, Value]};
+  {?kernel, elem, [Tuple, Index], fun([Index, Tuple]) -> [Tuple, Index] end};
+inner_rewrite(erl_to_ex, _Meta, erlang, setelement, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Term]) ->
+  {?kernel, put_elem, [Tuple, Index, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};
 
 inner_rewrite(erl_to_ex, _Meta, erlang, 'orelse', [_, _] = Args) ->
-  {?kernel, 'or', Args};
+  {?kernel, 'or', Args, fun identity/1};
 inner_rewrite(erl_to_ex, _Meta, erlang, 'andalso', [_, _] = Args) ->
-  {?kernel, 'and', Args};
+  {?kernel, 'and', Args, fun identity/1};
 
-inner_rewrite(_To, _Meta, Mod, Fun, Args) -> {Mod, Fun, Args}.
+inner_rewrite(ex_to_erl, _Meta, Mod, Fun, Args) -> {Mod, Fun, Args};
+inner_rewrite(erl_to_ex, _Meta, Mod, Fun, Args) -> {Mod, Fun, Args, fun identity/1}.
+
+identity(Arg) -> Arg.
 
 increment(_Meta, Number) when is_number(Number) ->
   Number + 1;

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

@@ -317,25 +317,25 @@ defmodule Module.Types.ExprTest do
       assert typecheck!([x], elem({:ok, x}, 0)) == dynamic(atom([:ok]))
       assert typecheck!([x], elem({:ok, x}, 1)) == dynamic(term())
 
-      assert typeerror!([<<x::integer>>], elem(x, 0)) |> strip_ansi() ==
+      assert typeerror!([<<x::float>>], elem(x, 0)) |> strip_ansi() ==
                ~l"""
                incompatible types given to Kernel.elem/2:
 
                    elem(x, 0)
 
                given types:
 
-                   integer(), integer()
+                   float(), integer()
 
                but expected one of:
 
-                   integer(), {...}
+                   {...}, integer()
 
                where "x" was given the type:
 
-                   # type: integer()
+                   # type: float()
                    # from: types_test.ex:LINE-1
-                   <<x::integer>>
+                   <<x::float>>
                """
 
       assert typeerror!(elem({:ok, 123}, 2)) ==
@@ -362,25 +362,25 @@ defmodule Module.Types.ExprTest do
       assert typecheck!(Tuple.insert_at({:ok, 123}, 2, "foo")) ==
                tuple([atom([:ok]), integer(), binary()])
 
-      assert typeerror!([<<x::integer>>], Tuple.insert_at(x, 0, "foo")) |> strip_ansi() ==
+      assert typeerror!([<<x::float>>], Tuple.insert_at(x, 0, "foo")) |> strip_ansi() ==
                ~l"""
                incompatible types given to Tuple.insert_at/3:
 
                    Tuple.insert_at(x, 0, "foo")
 
                given types:
 
-                   integer(), integer(), binary()
+                   float(), integer(), binary()
 
                but expected one of:
 
-                   integer(), {...}, term()
+                   {...}, integer(), term()
 
                where "x" was given the type:
 
-                   # type: integer()
+                   # type: float()
                    # from: types_test.ex:LINE-1
-                   <<x::integer>>
+                   <<x::float>>
                """
 
       assert typeerror!(Tuple.insert_at({:ok, 123}, 3, "foo")) ==
@@ -401,25 +401,25 @@ defmodule Module.Types.ExprTest do
       assert typecheck!([x], Tuple.delete_at({:ok, x}, 0)) == dynamic(tuple([term()]))
       assert typecheck!([x], Tuple.delete_at({:ok, x}, 1)) == dynamic(tuple([atom([:ok])]))
 
-      assert typeerror!([<<x::integer>>], Tuple.delete_at(x, 0)) |> strip_ansi() ==
+      assert typeerror!([<<x::float>>], Tuple.delete_at(x, 0)) |> strip_ansi() ==
                ~l"""
                incompatible types given to Tuple.delete_at/2:
 
                    Tuple.delete_at(x, 0)
 
                given types:
 
-                   integer(), integer()
+                   float(), integer()
 
                but expected one of:
 
-                   integer(), {...}
+                   {...}, integer()
 
                where "x" was given the type:
 
-                   # type: integer()
+                   # type: float()
                    # from: types_test.ex:LINE-1
-                   <<x::integer>>
+                   <<x::float>>
                """
 
       assert typeerror!(Tuple.delete_at({:ok, 123}, 2)) ==