Show undefined function errors even on variable failure, closes #13465

Author: josevalim

lib/elixir/src/elixir.hrl

@@ -11,6 +11,9 @@
 -define(tracker, 'Elixir.Kernel.LexicalTracker').
 
 -record(elixir_ex, {
+  %% Stores that the function will fail, which can be used
+  %% to run more expensive checks upfront
+  tainted_function=false,
   %% Stores if __CALLER__ is allowed
   caller=false,
   %% Stores the variables available before a match.

lib/elixir/src/elixir_expand.erl

@@ -379,15 +379,20 @@ expand({'^', Meta, [Arg]}, #elixir_ex{prematch={Prematch, _, _}, vars={_, Write}
 
     _ ->
       function_error(Meta, E, ?MODULE, {invalid_arg_for_pin, Arg}),
-      {{'^', Meta, [Arg]}, S, E}
+      {{'^', Meta, [Arg]}, S#elixir_ex{tainted_function=true}, E}
   end;
 expand({'^', Meta, [Arg]}, S, E) ->
   function_error(Meta, E, ?MODULE, {pin_outside_of_match, Arg}),
-  {{'^', Meta, [Arg]}, S, E};
+  {{'^', Meta, [Arg]}, S#elixir_ex{tainted_function=true}, E};
 
 expand({'_', Meta, Kind} = Var, S, #{context := Context} = E) when is_atom(Kind) ->
-  (Context /= match) andalso function_error(Meta, E, ?MODULE, unbound_underscore),
-  {Var, S, E};
+  case Context of
+    match ->
+      {Var, S, E};
+    _ ->
+      function_error(Meta, E, ?MODULE, unbound_underscore),
+      {Var, S#elixir_ex{tainted_function=true}, E}
+  end;
 
 expand({Name, Meta, Kind}, S, #{context := match} = E) when is_atom(Name), is_atom(Kind) ->
   #elixir_ex{
@@ -476,7 +481,7 @@ expand({Name, Meta, Kind}, S, E) when is_atom(Name), is_atom(Kind) ->
         %% TODO: Remove this clause on v2.0 as we will raise by default
         {if_undefined, raise} ->
           function_error(Meta, E, ?MODULE, {undefined_var, Name, Kind}),
-          {{Name, Meta, Kind}, S, E};
+          {{Name, Meta, Kind}, S#elixir_ex{tainted_function=true}, E};
 
         %% TODO: Remove this clause on v2.0 as we will no longer support warn
         _ when Error == warn ->
@@ -485,12 +490,12 @@ expand({Name, Meta, Kind}, S, E) when is_atom(Name), is_atom(Kind) ->
 
         _ when Error == pin ->
           function_error(Meta, E, ?MODULE, {undefined_var_pin, Name, Kind}),
-          {{Name, Meta, Kind}, S, E};
+          {{Name, Meta, Kind}, S#elixir_ex{tainted_function=true}, E};
 
         _ when Error == raise ->
           SpanMeta =  elixir_env:calculate_span(Meta, Name),
           function_error(SpanMeta, E, ?MODULE, {undefined_var, Name, Kind}),
-          {{Name, SpanMeta, Kind}, S, E}
+          {{Name, SpanMeta, Kind}, S#elixir_ex{tainted_function=true}, E}
       end
   end;
 
@@ -950,6 +955,11 @@ expand_remote(Receiver, DotMeta, Right, Meta, Args, S, SL, #{context := Context}
     Context =:= nil ->
       AttachedMeta = attach_runtime_module(Receiver, Meta, S, E),
       {EArgs, {SA, _}, EA} = mapfold(fun expand_arg/3, {SL, S}, E, Args),
+
+      SA#elixir_ex.tainted_function andalso is_atom(Receiver) andalso
+        (not is_loaded_and_exported(Receiver, Right, Args)) andalso
+        elixir_errors:file_warn(Meta, E, ?MODULE, {undefined_function, Receiver, Right, length(Args)}),
+
       Rewritten = elixir_rewrite:rewrite(Receiver, DotMeta, Right, AttachedMeta, EArgs),
       {Rewritten, elixir_env:close_write(SA, S), EA};
 
@@ -970,6 +980,10 @@ expand_remote(Receiver, DotMeta, Right, Meta, Args, _, _, E) ->
   Call = {{'.', DotMeta, [Receiver, Right]}, Meta, Args},
   file_error(Meta, E, ?MODULE, {invalid_call, Call}).
 
+is_loaded_and_exported(Receiver, Fun, Args) ->
+  (code:ensure_loaded(Receiver) =:= {module, Receiver}) andalso
+    erlang:function_exported(Receiver, Fun, length(Args)).
+
 attach_runtime_module(Receiver, Meta, S, _E) ->
   case lists:member(Receiver, S#elixir_ex.runtime_modules) of
     true -> [{runtime_module, true} | Meta];
@@ -1127,6 +1141,11 @@ assert_no_underscore_clause_in_cond(_Other, _E) ->
 
 %% Errors
 
+format_error({undefined_function, Module, Fun, Arity}) ->
+  Opts = [{module, Module}, {function, Fun}, {arity, Arity}],
+  Exception = 'Elixir.UndefinedFunctionError':exception(Opts),
+  {BlamedException, _} = 'Elixir.UndefinedFunctionError':blame(Exception, []),
+  'Elixir.UndefinedFunctionError':message(BlamedException);
 format_error(invalid_match_on_zero_float) ->
   "pattern matching on 0.0 is equivalent to matching only on +0.0. Instead you must match on +0.0 or -0.0";
 format_error({useless_literal, Term}) ->

lib/elixir/test/elixir/kernel/errors_test.exs

@@ -7,7 +7,7 @@ Code.require_file("../test_helper.exs", __DIR__)
 defmodule Kernel.ErrorsTest do
   use ExUnit.Case, async: true
 
-  defmacro hello do
+  defmacro hello(_) do
     quote location: :keep do
       def hello, do: :world
     end
@@ -159,6 +159,59 @@ defmodule Kernel.ErrorsTest do
     )
   end
 
+  test "cascading from undefined variables" do
+    # Test that we show undefined modules/functions/macros on variable failure,
+    # as sometimes the variable failure come from a missing module or require
+    assert_compile_error(
+      [
+        "nofile:3:23",
+        "undefined variable \"bar\"",
+        "nofile:3:19",
+        "function UnknownModule.foo/1 is undefined (module UnknownModule is not available)"
+      ],
+      ~c"""
+      defmodule Sample do
+        def foo do
+          UnknownModule.foo(bar)
+        end
+      end
+      """
+    )
+
+    assert_compile_error(
+      [
+        "nofile:3:20",
+        "undefined variable \"bar\"",
+        "nofile:3:16",
+        "function Enumerable.foo/1 is undefined or private"
+      ],
+      ~c"""
+      defmodule Sample do
+        def foo do
+          Enumerable.foo(bar)
+        end
+      end
+      """
+    )
+
+    assert_compile_error(
+      [
+        "nofile:3:29",
+        "undefined variable \"bar\"",
+        "nofile:3:23",
+        "function Kernel.ErrorsTest.hello/1 is undefined or private",
+        "there is a macro with the same name and arity"
+      ],
+      ~c"""
+      defmodule Sample do
+        def foo do
+          Kernel.ErrorsTest.hello(bar)
+        end
+      end
+      """
+    )
+  end
+
   test "recursive variables on definition" do
     assert_compile_error(
       [
@@ -677,7 +730,7 @@ defmodule Kernel.ErrorsTest do
     defmodule Kernel.ErrorsTest.DefDefmacroClauseChange do
       require Kernel.ErrorsTest
       defp hello, do: :world
-      Kernel.ErrorsTest.hello()
+      Kernel.ErrorsTest.hello(:ok)
     end
     """)
   end