Raise for undefined function within unused function

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -63,37 +63,30 @@ defmodule Module.Types do
 
     stack = stack(:infer, file, module, {:__info__, 1}, :all, env, handler)
 
-    {types, %{local_sigs: local_sigs}} =
-      for {fun_arity, kind, meta, clauses} = def <- defs, reduce: {[], context()} do
+    {types, %{local_sigs: local_sigs} = context} =
+      for {fun_arity, kind, meta, _clauses} = def <- defs,
+          kind in [:def, :defmacro] or (kind == :defmacrop and is_map_key(defmacrop, fun_arity)),
+          reduce: {[], context()} do
         {types, context} ->
-          cond do
-            kind in [:def, :defmacro] ->
-              finder = fn _ -> {infer_mode(kind, infer_signatures?), def} end
-              {_kind, inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
-
-              if infer_signatures? and kind == :def and fun_arity not in @no_infer do
-                {[{fun_arity, inferred} | types], context}
-              else
-                {types, context}
-              end
-
-            kind == :defmacrop and is_map_key(defmacrop, fun_arity) ->
-              # Bypass the caching structure for defmacrop, that's because
-              # we don't need them stored in the signatures when we perform
-              # unreachable checks. This may cause defmacrop to be traversed
-              # twice if it uses default arguments (which is the only way
-              # to refer to another defmacrop in definitions) but that should
-              # be cheap anyway.
-              {_kind, _inferred, context} =
-                local_handler(fun_arity, kind, meta, clauses, :traversal, stack, context)
-
-              {types, context}
-
-            true ->
-              {types, context}
+          finder = fn _ -> {infer_mode(kind, infer_signatures?), def} end
+          {_kind, inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
+
+          if infer_signatures? and kind == :def and fun_arity not in @no_infer do
+            {[{fun_arity, inferred} | types], context}
+          else
+            {types, context}
           end
       end
 
+    for {fun_arity, kind, meta, _clauses} = def <- defs,
+        kind in [:defp, :defmacrop],
+        reduce: context do
+      context ->
+        finder = fn _ -> {:traversal, def} end
+        {_kind, _inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
+        context
+    end
+
     unreachable =
       for {fun_arity, _kind, _meta, _defaults} = info <- private,
           warn_unused_def(info, local_sigs, defmacrop, env),

lib/elixir/src/elixir_expand.erl

@@ -887,7 +887,7 @@ assert_no_ambiguous_op(Name, Meta, [Arg], S, E) ->
 assert_no_ambiguous_op(_Atom, _Meta, _Args, _S, _E) ->
   ok.
 
-expand_local(Meta, Name, Args, S, #{module := Module, function := Function, context := Context} = E)
+expand_local(Meta, Name, Args, S, #{function := Function, context := Context} = E)
     when Function /= nil ->
   %% In case we have the wrong context, we log a module error
   %% so we can print multiple entries at the same time.

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

@@ -123,6 +123,17 @@ defmodule Kernel.ErrorsTest do
     )
   end
 
+  test "undefined function within unused function" do
+    assert_compile_error(
+      ["nofile:2:8", "undefined function bar/0"],
+      ~c"""
+      defmodule Sample do
+        defp foo, do: bar()
+      end
+      """
+    )
+  end
+
   test "undefined non-local function" do
     assert_compile_error(
       ["nofile:1:1", "undefined function call/2 (there is no such import)"],