Use Compiler to track macro using

katafrakt · katafrakt · commit e10a846565a3 · 2026-04-27T11:05:25.000+02:00
diff --git a/lib/elixir_sense/core/compiler.ex b/lib/elixir_sense/core/compiler.ex
@@ -948,6 +948,27 @@ defmodule ElixirSense.Core.Compiler do
 
   # Macro handling
 
+  defp expand_macro(
+         meta,
+         Kernel,
+         :use,
+         [target_module | _opts] = args,
+         callback,
+         state,
+         env
+       ) do
+    {expanded_module, state, env} = expand(target_module, state, env)
+
+    state =
+      if is_atom(expanded_module) do
+        State.add_use(expanded_module, state, env)
+      else
+        state
+      end
+
+    expand_macro_callback(meta, Kernel, :use, args, callback, state, env)
+  end
+
   defp expand_macro(
          meta,
          Kernel,
@@ -2153,8 +2174,10 @@ defmodule ElixirSense.Core.Compiler do
       # If expanding the macro fails, we just give up.
       _kind, _payload ->
         # Logger.warning(Exception.format(kind, payload, __STACKTRACE__))
+        uses = state.uses
         # look for cursor in args
         {_ast, state, _env} = expand(args, state, env)
+        state = %{state | uses: uses}
 
         {{{:., meta, [module, fun]}, meta, args}, state, env}
     else
diff --git a/lib/elixir_sense/core/compiler/state.ex b/lib/elixir_sense/core/compiler/state.ex
@@ -48,6 +48,7 @@ defmodule ElixirSense.Core.Compiler.State do
           attributes: list(list(ElixirSense.Core.State.AttributeInfo.t())),
           scope_attributes: list(list(atom)),
           behaviours: %{optional(module) => [module]},
+          uses: %{optional(module) => [module]},
           specs: specs_t,
           types: types_t,
           mods_funs_to_positions: mods_funs_to_positions_t,
@@ -88,6 +89,7 @@ defmodule ElixirSense.Core.Compiler.State do
   defstruct attributes: [[]],
             scope_attributes: [[]],
             behaviours: %{},
+            uses: %{},
             specs: %{},
             types: %{},
             mods_funs_to_positions: %{},
@@ -1050,6 +1052,12 @@ defmodule ElixirSense.Core.Compiler.State do
 
   def add_behaviour(_module, %__MODULE__{} = state, env), do: {nil, state, env}
 
+  def add_use(module, %__MODULE__{} = state, env) when is_atom(module) and not is_nil(module) do
+    update_in(state.uses[env.module], &Enum.uniq([module | &1 || []]))
+  end
+
+  def add_use(_module, %__MODULE__{} = state, _env), do: state
+
   def register_doc(%__MODULE__{} = state, env, :moduledoc, doc_arg) do
     current_module = env.module
     doc_arg_formatted = format_doc_arg(doc_arg)
diff --git a/lib/elixir_sense/core/metadata.ex b/lib/elixir_sense/core/metadata.ex
@@ -25,6 +25,7 @@ defmodule ElixirSense.Core.Metadata do
           specs: ElixirSense.Core.Compiler.State.specs_t(),
           structs: ElixirSense.Core.Compiler.State.structs_t(),
           records: ElixirSense.Core.Compiler.State.records_t(),
+          uses: %{optional(module) => [module]},
           error: nil | term,
           first_alias_positions: map(),
           moduledoc_positions: map()
@@ -41,6 +42,7 @@ defmodule ElixirSense.Core.Metadata do
             specs: %{},
             structs: %{},
             records: %{},
+            uses: %{},
             error: nil,
             first_alias_positions: %{},
             moduledoc_positions: %{}
@@ -62,6 +64,7 @@ defmodule ElixirSense.Core.Metadata do
       specs: acc.specs,
       structs: acc.structs,
       records: acc.records,
+      uses: acc.uses,
       mods_funs_to_positions: acc.mods_funs_to_positions,
       lines_to_env: acc.lines_to_env,
       vars_info_per_scope_id: acc.vars_info_per_scope_id,
diff --git a/lib/elixir_sense/core/parser.ex b/lib/elixir_sense/core/parser.ex
@@ -190,6 +190,7 @@ defmodule ElixirSense.Core.Parser do
       specs: acc.specs,
       structs: acc.structs,
       records: acc.records,
+      uses: acc.uses,
       mods_funs_to_positions: acc.mods_funs_to_positions,
       cursor_env: acc.cursor_env,
       closest_env: acc.closest_env,
diff --git a/lib/elixir_sense/providers/definition/locator.ex b/lib/elixir_sense/providers/definition/locator.ex
@@ -359,13 +359,22 @@ defmodule ElixirSense.Providers.Definition.Locator do
 
   defp find_function_in_module_using_macro(mod, fun, metadata) do
     if Map.has_key?(metadata.mods_funs_to_positions, {mod, nil, nil}) do
-      # Module is in the current source - use metadata.source
-      find_used_modules_and_search_in_source(metadata.source, mod, fun)
+      # Module is in the current source - use metadata.uses
+      used_modules = Map.get(metadata.uses, mod, [])
+
+      Enum.find_value(used_modules, fn used_module ->
+        search_in_using_macro(used_module, fun)
+      end)
     else
-      # Module is external - try to get source file
+      # Module is external - read the file contents and parse it
       with file when not is_nil(file) <- get_module_source_file(mod),
            {:ok, content} <- File.read(file) do
-        find_used_modules_and_search_in_source(content, mod, fun)
+        external_metadata = Parser.parse_string(content, false, false, nil)
+        used_modules = Map.get(external_metadata.uses, mod, [])
+
+        Enum.find_value(used_modules, fn used_module ->
+          search_in_using_macro(used_module, fun)
+        end)
       else
         _ -> nil
       end
@@ -380,74 +389,6 @@ defmodule ElixirSense.Providers.Definition.Locator do
     _, _ -> nil
   end
 
-  defp find_used_modules_and_search_in_source(source, mod, fun) do
-    with {:ok, ast} <- Code.string_to_quoted(source) do
-      collect_use_statements(ast, mod)
-      |> Enum.find_value(fn used_module ->
-        search_in_using_macro(used_module, fun)
-      end)
-    else
-      _ -> nil
-    end
-  end
-
-  defp collect_use_statements(ast, mod) do
-    target_parts = Module.split(mod)
-
-    {_, {_, modules}} =
-      Macro.traverse(
-        ast,
-        {[], []},
-        fn
-          {:defmodule, _meta, [module_ast | _]} = node, {stack, modules} ->
-            module_parts = module_ast_parts(module_ast)
-
-            full_parts =
-              case stack do
-                [parent_parts | _] when length(module_parts) == 1 ->
-                  parent_parts ++ module_parts
-
-                _ ->
-                  module_parts
-              end
-
-            {node, {[full_parts | stack], modules}}
-
-          {:use, _meta, [module_ast | _]} = node, {[current_parts | _] = stack, modules} ->
-            modules =
-              if current_parts == target_parts do
-                module = resolve_use_module(module_ast, %State.Env{aliases: []})
-                if module, do: [module | modules], else: modules
-              else
-                modules
-              end
-
-            {node, {stack, modules}}
-
-          node, acc ->
-            {node, acc}
-        end,
-        fn
-          {:defmodule, _meta, [_ | _]} = node, {[_ | rest], modules} ->
-            {node, {rest, modules}}
-
-          node, acc ->
-            {node, acc}
-        end
-      )
-
-    Enum.reverse(modules)
-  end
-
-  defp module_ast_parts({:__aliases__, _meta, parts}) do
-    parts
-    |> Module.concat()
-    |> Module.split()
-  end
-
-  defp module_ast_parts(atom) when is_atom(atom), do: Module.split(atom)
-  defp module_ast_parts(_), do: []
-
   defp search_in_using_macro(module, fun) do
     case Location.find_mod_fun_source(module, :__using__, :any) do
       %Location{file: file, line: using_line, column: using_col} when not is_nil(file) ->
diff --git a/test/elixir_sense/providers/definition/locator_test.exs b/test/elixir_sense/providers/definition/locator_test.exs
@@ -95,4 +95,158 @@ defmodule ElixirSense.Providers.Definition.LocatorTest do
     assert location.line == 4
     assert location.column == 11
   end
+
+  test "finds definition when using Kernel.use qualified call" do
+    code = """
+    defmodule MyModule do
+      Kernel.use(ElixirSense.Providers.Definition.LocatorTest.MyBehaviour)
+
+      def test do
+        my_function()
+      end
+    end
+    """
+
+    {line, column} = {5, 5}
+
+    location = Locator.definition(code, line, column)
+
+    assert location != nil
+    assert location.type == :function
+    assert location.line == 4
+    assert location.column == 11
+  end
+
+  test "finds definition when using module alias" do
+    code = """
+    defmodule MyModule do
+      alias ElixirSense.Providers.Definition.LocatorTest.MyBehaviour
+
+      use MyBehaviour
+
+      def test do
+        my_function()
+      end
+    end
+    """
+
+    {line, column} = {7, 5}
+
+    location = Locator.definition(code, line, column)
+
+    assert location != nil
+    assert location.type == :function
+    assert location.line == 4
+    assert location.column == 11
+  end
+
+  test "finds definition when using module with custom alias" do
+    code = """
+    defmodule MyModule do
+      alias ElixirSense.Providers.Definition.LocatorTest.MyBehaviour, as: MyB
+
+      use MyB
+
+      def test do
+        my_function()
+      end
+    end
+    """
+
+    {line, column} = {7, 5}
+
+    location = Locator.definition(code, line, column)
+
+    assert location != nil
+    assert location.type == :function
+    assert location.line == 4
+    assert location.column == 11
+  end
+
+  test "no false positive when local function named use exists" do
+    code = """
+    defmodule MyModule do
+      defp use(_module), do: nil
+
+      use ElixirSense.Providers.Definition.LocatorTest.MyBehaviour
+
+      def test do
+        use(SomeModule)
+        my_function()
+      end
+    end
+    """
+
+    {line, column} = {8, 5}
+
+    location = Locator.definition(code, line, column)
+
+    assert location != nil
+    assert location.type == :function
+    # should find the function from __using__ macro, not be confused by local use/1
+    assert location.line == 4
+    assert location.column == 11
+  end
+
+  describe "modules in external file" do
+    test "finds definition via external module using Kernel.use qualified call" do
+      code = """
+      defmodule MyModule do
+        def test do
+          ElixirSenseExample.ModuleUsingKernelUse.using_macro_function()
+        end
+      end
+      """
+
+      {line, column} = {3, 45}
+
+      location = Locator.definition(code, line, column)
+
+      assert location != nil
+      assert location.type == :function
+      assert location.file =~ "using_macro_example.ex"
+      assert location.line == 4
+      assert location.column == 11
+    end
+
+    test "finds definition via external module using aliased module" do
+      code = """
+      defmodule MyModule do
+        def test do
+          ElixirSenseExample.ModuleUsingAlias.using_macro_function()
+        end
+      end
+      """
+
+      {line, column} = {3, 42}
+
+      location = Locator.definition(code, line, column)
+
+      assert location != nil
+      assert location.type == :function
+      assert location.file =~ "using_macro_example.ex"
+      assert location.line == 4
+      assert location.column == 11
+    end
+
+    test "finds definition via external module that has other local functions" do
+      code = """
+      defmodule MyModule do
+        def test do
+          ElixirSenseExample.ModuleWithLocalUse.using_macro_function()
+        end
+      end
+      """
+
+      {line, column} = {3, 44}
+
+      location = Locator.definition(code, line, column)
+
+      assert location != nil
+      assert location.type == :function
+      assert location.file =~ "using_macro_example.ex"
+      assert location.line == 4
+      assert location.column == 11
+    end
+  end
 end
diff --git a/test/support/using_macro_example.ex b/test/support/using_macro_example.ex
@@ -9,3 +9,29 @@ end
 defmodule ElixirSenseExample.ModuleUsingMacroExample do
   use ElixirSenseExample.UsingMacroExample
 end
+
+# Module using Kernel.use qualified call (tests reviewer concern #1)
+defmodule ElixirSenseExample.ModuleUsingKernelUse do
+  Kernel.use(ElixirSenseExample.UsingMacroExample)
+end
+
+# Module using aliased module (tests reviewer concern #2)
+defmodule ElixirSenseExample.ModuleUsingAlias do
+  alias ElixirSenseExample.UsingMacroExample, as: MyMacro
+
+  use MyMacro
+end
+
+# Module with local function named use (tests reviewer concern #3)
+# This tests that a local function named `use` doesn't confuse use tracking
+defmodule ElixirSenseExample.ModuleWithLocalUse do
+  # This local function exists but won't shadow the Kernel.use macro
+  # The test verifies that proper AST expansion correctly identifies Kernel.use
+  defp my_use(_module), do: nil
+
+  use ElixirSenseExample.UsingMacroExample
+
+  def call_local_use do
+    my_use(SomeModule)
+  end
+end
