wip

lukaszsamson · lukaszsamson · commit 0f998ffa7043 · 2025-08-03T11:23:49.000+02:00
diff --git a/apps/language_server/lib/language_server/providers/execute_command/llm_docs_aggregator.ex b/apps/language_server/lib/language_server/providers/execute_command/llm_docs_aggregator.ex
@@ -133,12 +133,33 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
           list when is_list(list) and list != [] ->
             results =
               Enum.map(list, fn callback_info ->
-                %{
+                base_result = %{
                   module: inspect(module),
                   callback: Atom.to_string(function),
                   arity: callback_info[:arity] || arity,
                   documentation: callback_info[:documentation] || ""
                 }
+                
+                # Add spec if available
+                base_result = if callback_info[:spec] do
+                  Map.put(base_result, :spec, callback_info[:spec])
+                else
+                  base_result
+                end
+                
+                # Add kind if available  
+                base_result = if callback_info[:kind] do
+                  Map.put(base_result, :kind, callback_info[:kind])
+                else
+                  base_result
+                end
+                
+                # Add metadata if available
+                if callback_info[:metadata] && callback_info[:metadata] != %{} do
+                  Map.put(base_result, :metadata, callback_info[:metadata])
+                else
+                  base_result
+                end
               end)
 
             {:ok, results}
@@ -507,27 +528,6 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
   defp aggregate_callback_docs(module, callback, arity) do
     ensure_loaded(module)
 
-    # First try to get callback metadata from raw docs
-    callback_metadata_map =
-      case NormalizedCode.get_docs(module, :callback_docs) do
-        docs when is_list(docs) ->
-          docs
-          |> Enum.filter(fn
-            {{^callback, callback_arity}, _, _, _, _} ->
-              arity == nil or callback_arity == arity
-
-            _ ->
-              false
-          end)
-          |> Enum.map(fn {{name, cb_arity}, _, _, _, metadata} ->
-            {{name, cb_arity}, metadata}
-          end)
-          |> Map.new()
-
-        _ ->
-          %{}
-      end
-
     # Get callback documentation using Introspection
     callback_docs = Introspection.get_callbacks_with_docs(module)
 
@@ -543,14 +543,18 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
       end)
 
     Enum.map(callback_infos, fn callback_info ->
-      %{
+      callback_result = %{
         callback: Atom.to_string(callback),
         arity: callback_info.arity,
+        documentation: extract_doc(callback_info.doc),
         spec: callback_info.callback,
         kind: callback_info.kind,
-        documentation: extract_doc(callback_info.doc),
-        metadata: Map.get(callback_metadata_map, {callback, callback_info.arity}, %{})
+        metadata: callback_info.metadata
       }
+      
+      callback_result = Map.put(callback_result, :metadata, callback_info.metadata)
+      
+      callback_result
     end)
   end
 
@@ -658,7 +662,7 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
       spec_part =
         if section[:specs] && section.specs != [],
           do:
-            "\n\n**Specs:**\n#{Enum.map_join(section.specs, "\n", fn s -> "```elixir\n@spec #{s}\n```" end)}",
+            "\n\n**Specs:**\n#{Enum.map_join(section.specs, "\n", fn s -> "```elixir\n#{s}\n```" end)}",
           else: ""
 
       metadata_part = format_metadata_section(section[:metadata])
diff --git a/apps/language_server/test/providers/execute_command/llm_docs_aggregator_test.exs b/apps/language_server/test/providers/execute_command/llm_docs_aggregator_test.exs
@@ -389,6 +389,185 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregatorTest
       assert String.contains?(type_result.documentation, "An example type")
     end
 
+    test "handles macro documentation with specs" do
+      modules = ["ElixirSenseExample.ModuleWithDocs.some_macro/2"]
+
+      assert {:ok, result} = LlmDocsAggregator.execute([modules], %{})
+
+      assert Map.has_key?(result, :results)
+      assert length(result.results) == 1
+
+      macro_result = hd(result.results)
+      assert macro_result.module == "ElixirSenseExample.ModuleWithDocs"
+      assert macro_result.function == "some_macro"
+      assert macro_result.arity == 2
+      assert macro_result.documentation =~ "An example macro"
+      
+      # Check that metadata is included (since: "1.1.0")
+      assert macro_result.documentation =~ "Since"
+      assert macro_result.documentation =~ "1.1.0"
+    end
+
+    test "handles macro documentation without arity" do
+      modules = ["ElixirSenseExample.ModuleWithDocs.some_macro"]
+
+      assert {:ok, result} = LlmDocsAggregator.execute([modules], %{})
+
+      assert Map.has_key?(result, :results)
+      # Should find at least the some_macro/2 (from the fixture)
+      assert length(result.results) >= 1
+
+      macro_result = result.results |> Enum.find(&(&1.arity == 2))
+      assert macro_result.module == "ElixirSenseExample.ModuleWithDocs"
+      assert macro_result.function == "some_macro"
+      assert macro_result.arity == 2
+      assert macro_result.documentation =~ "An example macro"
+    end
+
+    test "handles macrocallback documentation with arity" do
+      modules = ["ElixirSenseExample.ModuleWithDocs.some_macrocallback/1"]
+
+      assert {:ok, result} = LlmDocsAggregator.execute([modules], %{})
+
+      assert Map.has_key?(result, :results)
+      assert length(result.results) == 1
+
+      macrocallback_result = hd(result.results)
+      assert macrocallback_result.module == "ElixirSenseExample.ModuleWithDocs"
+      assert macrocallback_result.callback == "some_macrocallback"
+      assert macrocallback_result.arity == 1
+      assert macrocallback_result.documentation =~ "An example callback"
+      
+      # Check that we got the documentation (metadata may be formatted differently for callbacks)
+      assert macrocallback_result.documentation
+    end
+
+    test "handles macrocallback documentation without arity" do
+      modules = ["ElixirSenseExample.ModuleWithDocs.some_macrocallback"]
+
+      assert {:ok, result} = LlmDocsAggregator.execute([modules], %{})
+
+      assert Map.has_key?(result, :results)
+      assert length(result.results) >= 1
+
+      macrocallback_result = result.results |> Enum.find(&(&1.arity == 1))
+      assert macrocallback_result.module == "ElixirSenseExample.ModuleWithDocs"
+      assert macrocallback_result.callback == "some_macrocallback"
+      assert macrocallback_result.arity == 1
+      assert macrocallback_result.documentation =~ "An example callback"
+    end
+
+    test "verifies macro and macrocallback specs are included" do
+      # Test callback spec
+      assert {:ok, result} = LlmDocsAggregator.execute([["ElixirSenseExample.ModuleWithDocs.some_callback/1"]], %{})
+      assert Map.has_key?(result, :results)
+      assert length(result.results) == 1
+      
+      callback_result = hd(result.results)
+      assert Map.has_key?(callback_result, :spec)
+      assert Map.has_key?(callback_result, :kind)
+      assert Map.has_key?(callback_result, :metadata)
+      assert callback_result.spec == "@callback some_callback(integer()) :: atom()"
+      assert callback_result.kind == :callback
+      assert callback_result.metadata.since == "1.1.0"
+      
+      # Test macrocallback spec  
+      assert {:ok, result} = LlmDocsAggregator.execute([["ElixirSenseExample.ModuleWithDocs.some_macrocallback/1"]], %{})
+      assert Map.has_key?(result, :results)
+      assert length(result.results) == 1
+      
+      macrocallback_result = hd(result.results)
+      assert Map.has_key?(macrocallback_result, :spec)
+      assert Map.has_key?(macrocallback_result, :kind)
+      assert Map.has_key?(macrocallback_result, :metadata)
+      assert macrocallback_result.spec == "@macrocallback some_macrocallback(integer()) :: atom()"
+      assert macrocallback_result.kind == :macrocallback
+      assert macrocallback_result.metadata.since == "1.1.0"
+    end
+
+    test "verifies function documentation contains specs" do
+      # Test with ElixirSenseExample.ModuleWithDocs.some_fun/2 which has a @spec
+      modules = ["ElixirSenseExample.ModuleWithDocs.some_fun/2"]
+
+      assert {:ok, result} = LlmDocsAggregator.execute([modules], %{})
+
+      assert Map.has_key?(result, :results)
+      assert length(result.results) == 1
+
+      func_result = hd(result.results)
+      assert func_result.module == "ElixirSenseExample.ModuleWithDocs"
+      assert func_result.function == "some_fun"
+      assert func_result.arity == 2
+      assert func_result.documentation =~ "An example fun"
+      
+      # Verify that specs are included in the documentation
+      assert func_result.documentation =~ "**Specs:**"
+      assert func_result.documentation =~ "@spec some_fun"
+      assert func_result.documentation =~ "```elixir"
+      assert func_result.documentation =~ "integer()"
+    end
+
+    test "verifies macro documentation contains specs" do
+      # Test with ElixirSenseExample.ModuleWithDocs.some_macro/2 which has a @spec
+      modules = ["ElixirSenseExample.ModuleWithDocs.some_macro/2"]
+
+      assert {:ok, result} = LlmDocsAggregator.execute([modules], %{})
+
+      assert Map.has_key?(result, :results)
+      assert length(result.results) == 1
+
+      macro_result = hd(result.results)
+      assert macro_result.module == "ElixirSenseExample.ModuleWithDocs"
+      assert macro_result.function == "some_macro"
+      assert macro_result.arity == 2
+      assert macro_result.documentation =~ "An example macro"
+      
+      # Verify that specs are included in the macro documentation
+      assert macro_result.documentation =~ "**Specs:**"
+      assert macro_result.documentation =~ "@spec some_macro"
+      assert macro_result.documentation =~ "```elixir"
+      assert macro_result.documentation =~ "Macro.t()"
+    end
+
+    test "verifies function specs are properly formatted" do
+      # Test function without arity to get all arities
+      modules = ["ElixirSenseExample.ModuleWithDocs.some_fun"]
+
+      assert {:ok, result} = LlmDocsAggregator.execute([modules], %{})
+
+      assert Map.has_key?(result, :results)
+      assert length(result.results) >= 1
+
+      # Find the result with arity 2 (which has specs)
+      func_result = Enum.find(result.results, &(&1.arity == 2))
+      assert func_result
+      
+      # Verify spec formatting
+      assert func_result.documentation =~ "**Specs:**"
+      assert func_result.documentation =~ "```elixir"
+      assert func_result.documentation =~ "@spec some_fun(integer(), integer() | nil) :: integer()"
+    end
+
+    test "verifies macro specs are properly formatted" do
+      # Test macro without arity to get all arities
+      modules = ["ElixirSenseExample.ModuleWithDocs.some_macro"]
+
+      assert {:ok, result} = LlmDocsAggregator.execute([modules], %{})
+
+      assert Map.has_key?(result, :results)
+      assert length(result.results) >= 1
+
+      # Find the result with arity 2 (which has specs)
+      macro_result = Enum.find(result.results, &(&1.arity == 2))
+      assert macro_result
+      
+      # Verify spec formatting for macro
+      assert macro_result.documentation =~ "**Specs:**"
+      assert macro_result.documentation =~ "```elixir"
+      assert macro_result.documentation =~ "@spec some_macro(Macro.t(), Macro.t() | nil) :: Macro.t()"
+    end
+
+
     test "returns error for invalid arguments" do
       # Test with non-list argument
       assert {:ok, result} = LlmDocsAggregator.execute("String", %{})
diff --git a/apps/language_server/test/support/modules_with_docs.ex b/apps/language_server/test/support/modules_with_docs.ex
@@ -22,6 +22,7 @@ defmodule ElixirSenseExample.ModuleWithDocs do
   An example fun
   """
   @doc since: "1.1.0"
+  @spec some_fun(integer, integer | nil) :: integer
   def some_fun(a, b \\ nil), do: a + b
   @doc false
   def some_fun_doc_false(a, b \\ nil), do: a + b
@@ -31,6 +32,7 @@ defmodule ElixirSenseExample.ModuleWithDocs do
   An example macro
   """
   @doc since: "1.1.0"
+  @spec some_macro(Macro.t(), Macro.t() | nil) :: Macro.t()
   defmacro some_macro(a, b \\ nil), do: a + b
   @doc false
   defmacro some_macro_doc_false(a, b \\ nil), do: a + b
