Track all arities in imports inside quotes, closes #11651

Author: josevalim

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -59,6 +59,11 @@ defmodule Kernel.LexicalTracker do
     :gen_server.cast(pid, {:alias_dispatch, module})
   end
 
+  @doc false
+  def import_quoted(pid, module, function, arities) when is_atom(module) do
+    :gen_server.cast(pid, {:import_quoted, module, function, arities})
+  end
+
   @doc false
   def add_compile_env(pid, app, path, return) do
     :gen_server.cast(pid, {:compile_env, app, path, return})
@@ -170,6 +175,24 @@ defmodule Kernel.LexicalTracker do
     {:noreply, %{state | aliases: Map.delete(aliases, module)}}
   end
 
+  def handle_cast({:import_quoted, module, function, arities}, state) do
+    %{imports: imports} = state
+
+    imports =
+      case imports do
+        %{^module => modules_and_fas} ->
+          arities
+          |> Enum.reduce(modules_and_fas, &Map.delete(&2, {function, &1}))
+          |> Map.delete(module)
+          |> then(&Map.put(imports, module, &1))
+
+        %{} ->
+          imports
+      end
+
+    {:noreply, %{state | imports: imports}}
+  end
+
   def handle_cast({:set_file, file}, state) do
     {:noreply, %{state | file: file}}
   end

lib/elixir/src/elixir_dispatch.erl

@@ -6,7 +6,7 @@
   require_function/5, import_function/4,
   expand_import/7, expand_require/6,
   default_functions/0, default_macros/0, default_requires/0,
-  find_import/4, find_imports/4, format_error/1]).
+  find_import/4, find_imports/3, format_error/1]).
 -include("elixir.hrl").
 -import(ordsets, [is_element/2]).
 -define(kernel, 'Elixir.Kernel').
@@ -25,7 +25,7 @@ default_requires() ->
 find_import(Meta, Name, Arity, E) ->
   Tuple = {Name, Arity},
 
-  case find_dispatch(Meta, Tuple, [], E) of
+  case find_import_by_name_arity(Meta, Tuple, [], E) of
     {function, Receiver} ->
       elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),
       Receiver;
@@ -36,25 +36,37 @@ find_import(Meta, Name, Arity, E) ->
       false
   end.
 
-find_imports(Meta, Name, Arity, E) ->
-  Tuple = {Name, Arity},
+find_imports(Meta, Name, E) ->
+  Funs = ?key(E, functions),
+  Macs = ?key(E, macros),
 
-  case find_dispatch(Meta, Tuple, [], E) of
-    {function, Receiver} ->
-      elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),
-      [{Receiver, Arity}];
-    {macro, Receiver} ->
-      elixir_env:trace({imported_macro, Meta, Receiver, Name, Arity}, E),
-      [{Receiver, Arity}];
-    _ ->
-      []
-  end.
+  Acc0 = #{},
+  Acc1 = find_imports_by_name(Funs, Acc0, Name, Meta, E),
+  Acc2 = find_imports_by_name(Macs, Acc1, Name, Meta, E),
+
+  Imports = lists:sort(maps:to_list(Acc2)),
+  trace_import_quoted(Imports, Meta, Name, E),
+  Imports.
+
+trace_import_quoted([{Arity, Mod} | Imports], Meta, Name, E) ->
+  {Rest, Arities} = collect_trace_import_quoted(Imports, Mod, [], [Arity]),
+  elixir_env:trace({imported_quoted, Meta, Mod, Name, Arities}, E),
+  trace_import_quoted(Rest, Meta, Name, E);
+trace_import_quoted([], _Meta, _Name, _E) ->
+  ok.
+
+collect_trace_import_quoted([{Arity, Mod} | Imports], Mod, Acc, Arities) ->
+  collect_trace_import_quoted(Imports, Mod, Acc, [Arity | Arities]);
+collect_trace_import_quoted([Import | Imports], Mod, Acc, Arities) ->
+  collect_trace_import_quoted(Imports, Mod, [Import | Acc], Arities);
+collect_trace_import_quoted([], _Mod, Acc, Arities) ->
+  {lists:reverse(Acc), lists:reverse(Arities)}.
 
 %% Function retrieval
 
 import_function(Meta, Name, Arity, E) ->
   Tuple = {Name, Arity},
-  case find_dispatch(Meta, Tuple, [], E) of
+  case find_import_by_name_arity(Meta, Tuple, [], E) of
     {function, Receiver} ->
       elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),
       elixir_locals:record_import(Tuple, Receiver, ?key(E, module), ?key(E, function)),
@@ -134,15 +146,14 @@ dispatch_require(_Meta, Receiver, Name, Args, _S, _E, Callback) ->
 expand_import(Meta, {Name, Arity} = Tuple, Args, S, E, Extra, External) ->
   Module = ?key(E, module),
   Function = ?key(E, function),
-  Dispatch = find_dispatch(Meta, Tuple, Extra, E),
+  Dispatch = find_import_by_name_arity(Meta, Tuple, Extra, E),
 
   case Dispatch of
     {import, _} ->
       do_expand_import(Meta, Tuple, Args, Module, S, E, Dispatch);
     _ ->
       AllowLocals = External orelse ((Function /= nil) andalso (Function /= Tuple)),
-      Local = AllowLocals andalso
-                elixir_def:local_for(Meta, Name, Arity, [defmacro, defmacrop], E),
+      Local = AllowLocals andalso elixir_def:local_for(Meta, Name, Arity, [defmacro, defmacrop], E),
 
       case Dispatch of
         %% There is a local and an import. This is a conflict unless
@@ -246,15 +257,35 @@ caller(Line, E) ->
 required(Meta) ->
   lists:keyfind(required, 1, Meta) == {required, true}.
 
-find_dispatch(Meta, {_Name, Arity} = Tuple, Extra, E) ->
+find_imports_by_name([{Mod, Imports} | ModImports], Acc, Name, Meta, E) ->
+  NewAcc = find_imports_by_name(Name, Imports, Acc, Mod, Meta, E),
+  find_imports_by_name(ModImports, NewAcc, Name, Meta, E);
+find_imports_by_name([], Acc, _Name, _Meta, _E) ->
+  Acc.
+
+find_imports_by_name(Name, [{Name, Arity} | Imports], Acc, Mod, Meta, E) ->
+  case Acc of
+    #{Arity := OtherMod} ->
+      Error = {ambiguous_call, {Mod, OtherMod, Name, Arity}},
+      elixir_errors:form_error(Meta, E, ?MODULE, Error);
+
+    #{} ->
+      find_imports_by_name(Name, Imports, Acc#{Arity => Mod}, Mod, Meta, E)
+  end;
+find_imports_by_name(Name, [{ImportName, _} | Imports], Acc, Mod, Meta, E) when Name > ImportName ->
+  find_imports_by_name(Name, Imports, Acc, Mod, Meta, E);
+find_imports_by_name(_Name, _Imports, Acc, _Mod, _Meta, _E) ->
+  Acc.
+
+find_import_by_name_arity(Meta, {_Name, Arity} = Tuple, Extra, E) ->
   case is_import(Meta, Arity) of
     {import, _} = Import ->
       Import;
     false ->
       Funs = ?key(E, functions),
       Macs = Extra ++ ?key(E, macros),
-      FunMatch = find_dispatch(Tuple, Funs),
-      MacMatch = find_dispatch(Tuple, Macs),
+      FunMatch = find_import_by_name_arity(Tuple, Funs),
+      MacMatch = find_import_by_name_arity(Tuple, Macs),
 
       case {FunMatch, MacMatch} of
         {[], [Receiver]} -> {macro, Receiver};
@@ -268,16 +299,16 @@ find_dispatch(Meta, {_Name, Arity} = Tuple, Extra, E) ->
       end
   end.
 
-find_dispatch(Tuple, List) ->
+find_import_by_name_arity(Tuple, List) ->
   [Receiver || {Receiver, Set} <- List, is_element(Tuple, Set)].
 
 is_import(Meta, Arity) ->
   case lists:keyfind(imports, 1, Meta) of
     {imports, Imports} ->
       case lists:keyfind(context, 1, Meta) of
         {context, _} ->
-          case lists:keyfind(Arity, 2, Imports) of
-            {Receiver, Arity} -> {import, Receiver};
+          case lists:keyfind(Arity, 1, Imports) of
+            {Arity, Receiver} -> {import, Receiver};
             false -> false
           end;
         false -> false

lib/elixir/src/elixir_lexical.erl

@@ -70,6 +70,9 @@ trace({imported_function, _Meta, Module, Function, Arity}, #{lexical_tracker :=
 trace({imported_macro, _Meta, Module, Function, Arity}, #{lexical_tracker := Pid}) ->
   ?tracker:import_dispatch(Pid, Module, {Function, Arity}, compile),
   ok;
+trace({imported_quoted, _Meta, Module, Function, Arities}, #{lexical_tracker := Pid}) ->
+  ?tracker:import_quoted(Pid, Module, Function, Arities),
+  ok;
 trace({compile_env, App, Path, Return}, #{lexical_tracker := Pid}) ->
   ?tracker:add_compile_env(Pid, App, Path, Return),
   ok;

lib/elixir/src/elixir_quote.erl

@@ -330,7 +330,7 @@ do_quote({'&', Meta, [{'/', _, [{F, _, C}, A]}] = Args},
         Meta;
 
       Receiver ->
-        keystore(context, keystore(imports, Meta, [{Receiver, A}]), Q#elixir_quote.context)
+        keystore(context, keystore(imports, Meta, [{A, Receiver}]), Q#elixir_quote.context)
     end,
   do_quote_tuple('&', NewMeta, Args, Q, E);
 
@@ -380,7 +380,7 @@ do_quote(Other, _, _) ->
 
 import_meta(Meta, Name, Arity, Q, E) ->
   case (keyfind(import, Meta) == false) andalso
-      elixir_dispatch:find_imports(Meta, Name, Arity, E) of
+      elixir_dispatch:find_imports(Meta, Name, E) of
     [] ->
       case (Arity == 1) andalso keyfind(ambiguous_op, Meta) of
         {ambiguous_op, nil} -> keystore(ambiguous_op, Meta, Q#elixir_quote.context);

lib/elixir/test/elixir/kernel/expansion_test.exs

@@ -2306,7 +2306,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "expands size * unit" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
       import Kernel.ExpansionTarget
 
       assert expand(quote(do: <<x::13>>)) |> clean_meta([:alignment]) ==
@@ -2338,7 +2338,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "expands binary/bitstring specifiers" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
 
       assert expand(quote(do: <<x::binary>>)) |> clean_meta([:alignment]) ==
                quote(do: <<x()::binary()>>)
@@ -2363,7 +2363,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "expands utf* specifiers" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
 
       assert expand(quote(do: <<x::utf8>>)) |> clean_meta([:alignment]) ==
                quote(do: <<x()::utf8()>>)
@@ -2386,7 +2386,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "expands numbers specifiers" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
 
       assert expand(quote(do: <<x::integer>>)) |> clean_meta([:alignment]) ==
                quote(do: <<x()::integer()>>)
@@ -2412,7 +2412,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "expands macro specifiers" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
       import Kernel.ExpansionTarget
 
       assert expand(quote(do: <<x::seventeen>>)) |> clean_meta([:alignment]) ==
@@ -2424,7 +2424,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "expands macro in args" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
 
       before_expansion =
         quote do
@@ -2442,7 +2442,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "supports dynamic size" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
 
       before_expansion =
         quote do
@@ -2471,7 +2471,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "merges bitstrings" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
 
       assert expand(quote(do: <<x, <<y::signed-native>>, z>>)) |> clean_meta([:alignment]) ==
                quote(do: <<x()::integer(), y()::integer()-native()-signed(), z()::integer()>>)
@@ -2482,7 +2482,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "merges binaries" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
 
       assert expand(quote(do: "foo" <> x)) |> clean_meta([:alignment]) ==
                quote(do: <<"foo"::binary(), x()::binary()>>)
@@ -2496,7 +2496,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "guard expressions on size" do
-      import Kernel, except: [-: 2, +: 2, length: 1]
+      import Kernel, except: [-: 1, -: 2, +: 1, +: 2, length: 1]
 
       # Arithmetic operations with literals and variables are valid expressions
       # for bitstring size in OTP 23+
@@ -2524,7 +2524,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "map lookup on size" do
-      import Kernel, except: [-: 2]
+      import Kernel, except: [-: 1, -: 2]
 
       before_expansion =
         quote do
@@ -2572,7 +2572,7 @@ defmodule Kernel.ExpansionTest do
     # TODO: Simplify when we require Erlang/OTP 24
     if System.otp_release() >= "24" do
       test "16-bit floats" do
-        import Kernel, except: [-: 2]
+        import Kernel, except: [-: 1, -: 2]
 
         assert expand(quote(do: <<12.3::float-16>>)) |> clean_meta([:alignment]) ==
                  quote(do: <<12.3::float()-size(16)>>)

lib/elixir/test/elixir/kernel/quote_test.exs

@@ -566,6 +566,12 @@ defmodule Kernel.QuoteTest.ImportsHygieneTest do
     end
   end
 
+  defmacrop get_list_length_with_pipe do
+    quote do
+      'hello' |> length()
+    end
+  end
+
   defmacrop get_list_length_with_partial do
     quote do
       (&length(&1)).('hello')
@@ -581,6 +587,7 @@ defmodule Kernel.QuoteTest.ImportsHygieneTest do
   test "expand imports" do
     import Kernel, except: [length: 1]
     assert get_list_length() == 5
+    assert get_list_length_with_pipe() == 5
     assert get_list_length_with_partial() == 5
     assert get_list_length_with_function() == 5
   end
@@ -631,6 +638,6 @@ defmodule Kernel.QuoteTest.ImportsHygieneTest do
   test "checks the context also for variables to zero-arity functions" do
     import BinaryUtils
     {:int32, meta, __MODULE__} = quote(do: int32)
-    assert meta[:imports] == [{BinaryUtils, 0}]
+    assert meta[:imports] == [{0, BinaryUtils}]
   end
 end