Do not warn for functions generated by Erlang compiler (#9713)

Author: ericmj

lib/elixir/lib/module/checker.ex

@@ -216,6 +216,8 @@ defmodule Module.Checker do
   # TODO: Do not warn inside guards
   # TODO: Properly handle protocols
   defp warn_undefined?(_module, :__impl__, 1, _state), do: false
+  defp warn_undefined?(_module, :module_info, 0, _state), do: false
+  defp warn_undefined?(_module, :module_info, 1, _state), do: false
   defp warn_undefined?(:erlang, :orelse, 2, _state), do: false
   defp warn_undefined?(:erlang, :andalso, 2, _state), do: false
 

lib/elixir/lib/module/parallel_checker.ex

@@ -209,7 +209,11 @@ defmodule Module.ParallelChecker do
   end
 
   defp cache_from_module_map(ets, map) do
-    exports = [{{:__info__, 1}, :def} | definitions_to_exports(map.definitions)]
+    exports =
+      [{{:__info__, 1}, :def}] ++
+        behaviour_exports(map) ++
+        definitions_to_exports(map.definitions)
+
     deprecated = Map.new(map.deprecated)
     cache_info(ets, map.module, exports, deprecated)
   end
@@ -227,6 +231,7 @@ defmodule Module.ParallelChecker do
   defp info_exports(module) do
     Map.new(
       [{{:__info__, 1}, :def}] ++
+        behaviour_exports(module) ++
         Enum.map(module.__info__(:macros), &{&1, :defmacro}) ++
         Enum.map(module.__info__(:functions), &{&1, :def})
     )
@@ -268,6 +273,17 @@ defmodule Module.ParallelChecker do
     :ets.insert(ets, {{:cached, module}, true})
   end
 
+  defp behaviour_exports(%{is_behaviour: true}), do: [{{:behaviour_info, 1}, :def}]
+  defp behaviour_exports(%{is_behaviour: false}), do: []
+
+  defp behaviour_exports(module) when is_atom(module) do
+    if {:behaviour_info, 1} in module.module_info(:functions) do
+      [{{:behaviour_info, 1}, :def}]
+    else
+      []
+    end
+  end
+
   defp definitions_to_exports(definitions) do
     Enum.flat_map(definitions, fn {function, kind, _meta, _clauses} ->
       if kind in [:def, :defmacro] do

lib/elixir/src/elixir_erl.erl

@@ -549,7 +549,7 @@ signature_to_binary(Module, '__struct__', []) ->
 signature_to_binary(_, Name, Signature) ->
   'Elixir.Macro':to_string({Name, [], Signature}).
 
-checker_chunk(#{definitions := Definitions, deprecated := Deprecated}, NoWarnUndefined) ->
+checker_chunk(#{definitions := Definitions, deprecated := Deprecated, is_behaviour := IsBehaviour}, NoWarnUndefined) ->
   DeprecatedMap = maps:from_list(Deprecated),
 
   Exports =
@@ -564,12 +564,15 @@ checker_chunk(#{definitions := Definitions, deprecated := Deprecated}, NoWarnUnd
     end, [], Definitions),
 
   Contents = #{
-    exports => lists:sort(Exports),
+    exports => lists:sort(behaviour_info_exports(IsBehaviour) ++ Exports),
     no_warn_undefined => NoWarnUndefined
   },
 
   [{<<"ExCk">>, erlang:term_to_binary({elixir_checker_v1, Contents})}].
 
+behaviour_info_exports(true) -> [{{behaviour_info, 1}, #{kind => def, deprecated_reason => nil}}];
+behaviour_info_exports(false) -> [].
+
 split_no_warn_undefined([{no_warn_undefined, NoWarnUndefined} | CompileOpts], AccNWU, AccCO) ->
   split_no_warn_undefined(CompileOpts, list_wrap(NoWarnUndefined) ++ AccNWU, AccCO);
 split_no_warn_undefined([Opt | CompileOpts], AccNWU, AccCO) ->

lib/elixir/src/elixir_module.erl

@@ -133,7 +133,8 @@ compile(Line, Module, Block, Vars, E) ->
       definitions => AllDefinitions,
       unreachable => Unreachable,
       compile_opts => CompileOpts,
-      deprecated => get_deprecated(DataBag)
+      deprecated => get_deprecated(DataBag),
+      is_behaviour => is_behaviour(DataBag)
     },
 
     Binary = elixir_erl:compile(ModuleMap),
@@ -199,6 +200,9 @@ validate_on_load_attribute({on_load, Def}, Defs, File, Line) ->
   end;
 validate_on_load_attribute(false, _Defs, _File, _Line) -> ok.
 
+is_behaviour(DataBag) ->
+  ets:member(DataBag, {accumulate, callback}) orelse ets:member(DataBag, {accumulate, macrocallback}).
+
 %% An undef error for a function in the module being compiled might result in an
 %% exception message suggesting the current module is not loaded. This is
 %% misleading so use a custom reason.

lib/elixir/test/elixir/module/checker_test.exs

@@ -23,17 +23,34 @@ defmodule Module.CheckerTest do
           @deprecated "oops"
           def e, do: :ok
         end
+        """,
+        "b.ex" => """
+        defmodule B do
+          @callback f() :: :ok
+        end
+        """,
+        "c.ex" => """
+        defmodule C do
+          @macrocallback g() :: :ok
+        end
         """
       }
 
       modules = compile(files)
-      contents = read_chunk(modules[A])
 
-      assert contents.exports == [
+      assert read_chunk(modules[A]).exports == [
                {{:c, 0}, %{deprecated_reason: nil, kind: :def}},
                {{:d, 0}, %{deprecated_reason: nil, kind: :defmacro}},
                {{:e, 0}, %{deprecated_reason: "oops", kind: :def}}
              ]
+
+      assert read_chunk(modules[B]).exports == [
+               {{:behaviour_info, 1}, %{deprecated_reason: nil, kind: :def}}
+             ]
+
+      assert read_chunk(modules[C]).exports == [
+               {{:behaviour_info, 1}, %{deprecated_reason: nil, kind: :def}}
+             ]
     end
   end
 
@@ -60,6 +77,28 @@ defmodule Module.CheckerTest do
       assert_warnings(files, warning)
     end
 
+    test "handles built in functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: Kernel.module_info()
+          def b, do: Kernel.module_info(:functions)
+          def c, do: Kernel.__info__(:functions)
+          def d, do: GenServer.behaviour_info(:callbacks)
+          def e, do: Kernel.behaviour_info(:callbacks)
+        end
+        """
+      }
+
+      warning = """
+      warning: Kernel.behaviour_info/1 is undefined or private
+        a.ex:6: A.e/0
+
+      """
+
+      assert_warnings(files, warning)
+    end
+
     test "handles module body conditionals" do
       files = %{
         "a.ex" => """