trace module callbacks

Author: lukaszsamson

lib/elixir_sense/core/compiler.ex

@@ -1728,11 +1728,12 @@ defmodule ElixirSense.Core.Compiler do
     # here we handle module callbacks. Only before_compile macro callbacks are expanded as they
     # affect module body. Func before_compile callbacks are not executed. after_compile and after_verify
     # are not executed as we do not preform a real compilation
-    {state, _e_env} =
-      for args <- Map.get(state.attribute_store, {full, :before_compile}, []) do
+    {state, _e_env} = ~w(before_compile after_compile after_verify)a
+    |> Enum.reduce({state, e_env}, fn attribute, {state, env} ->
+      for args <- Map.get(state.attribute_store, {full, attribute}, []) do
         case args do
           {module, fun} -> [module, fun]
-          module -> [module, :__before_compile__]
+          module -> [module, :"__#{attribute}__"]
         end
       end
       |> Enum.reduce({state, e_env}, fn target, {state, env} ->
@@ -1744,16 +1745,23 @@ defmodule ElixirSense.Core.Compiler do
         # elixir dispatches callbacks by raw dispatch and eval_forms
         # instead we expand a bock with require and possibly expand macros
         # we do not attempt to exec function callbacks
+        args = case attribute do
+          :before_compile -> [env]
+          :after_compile -> [env, <<>>]
+          :after_verify -> [full]
+        end
+
         ast =
           {:__block__, [],
            [
              {:require, [], [hd(target)]},
-             {{:., [], target}, [], [env]}
+             {{:., [line: meta[:line]], target}, [line: meta[:line]], args}
            ]}
 
         {_result, state, env} = expand(ast, state, env)
         {State.remove_func_vars_scope(state, state_orig), env}
       end)
+    end)
 
     # restore vars from outer scope
     # restore version counter

test/elixir_sense/core/metadata_builder_test.exs

@@ -4844,7 +4844,7 @@ defmodule ElixirSense.Core.MetadataBuilderTest do
                },
                MyModule.Second => %StructInfo{
                  fields: [
-                   baz: {:%, [], [MyModule.First, {:%{}, [], [{:foo, :bar}]}]},
+                   baz: {:%, [{:line, 1}], [MyModule.First, {:%{}, [{:line, 1}], [{:foo, :bar}]}]},
                    __struct__: MyModule.Second
                  ]
                }
@@ -7519,7 +7519,74 @@ defmodule ElixirSense.Core.MetadataBuilderTest do
              } == state.calls
     end
 
-    # TODO track Kernel.SpecialForms calls?
+    defmodule ModuleCallbacks do
+      defmacro __before_compile_macro__(_env) do
+        quote do
+          def hello, do: "world"
+        end
+      end
+    
+      def __before_compile__(env) do
+        IO.inspect(env)
+      end
+    
+      def __after_compile__(env, _bytecode) do
+        IO.inspect(env)
+      end
+    
+      def __after_verify__(module) do
+        IO.inspect(module)
+        :ok
+      end
+    end
+
+    test "registers module callback calls" do
+      state =
+        """
+        defmodule WithCallbacks do
+          @before_compile {ElixirSense.Core.MetadataBuilderTest.ModuleCallbacks, :__before_compile_macro__}
+          @before_compile ElixirSense.Core.MetadataBuilderTest.ModuleCallbacks
+          @after_compile ElixirSense.Core.MetadataBuilderTest.ModuleCallbacks
+          @after_verify ElixirSense.Core.MetadataBuilderTest.ModuleCallbacks
+        end
+        """
+        |> string_to_state
+
+      assert state.calls[1] |> Enum.any?(fn info -> match?(%ElixirSense.Core.State.CallInfo{
+        arity: 1,
+        position: {1, nil},
+        mod: ElixirSense.Core.MetadataBuilderTest.ModuleCallbacks,
+        func: :__before_compile_macro__,
+        kind: :remote_macro
+      }, info) end)
+
+      assert state.calls[1] |> Enum.any?(fn info -> match?(%ElixirSense.Core.State.CallInfo{
+        arity: 1,
+        position: {1, nil},
+        mod: ElixirSense.Core.MetadataBuilderTest.ModuleCallbacks,
+        func: :__before_compile__,
+        kind: :remote_function
+      }, info) end)
+
+        assert state.calls[1] |> Enum.any?(fn info -> match?(%ElixirSense.Core.State.CallInfo{
+          arity: 2,
+          position: {1, nil},
+          mod: ElixirSense.Core.MetadataBuilderTest.ModuleCallbacks,
+          func: :__after_compile__,
+          kind: :remote_function
+        }, info) end)
+
+        assert state.calls[1] |> Enum.any?(fn info -> match?(%ElixirSense.Core.State.CallInfo{
+          arity: 1,
+          position: {1, nil},
+          mod: ElixirSense.Core.MetadataBuilderTest.ModuleCallbacks,
+          func: :__after_verify__,
+          kind: :remote_function
+        }, info) end)
+      # TODO: on_load and on_definition callbacks are not registered
+      # https://github.com/elixir-lang/elixir/issues/14427
+      # assert [] = state.calls[1]
+    end
 
     test "registers typespec no parens calls" do
       state =