cleanup

Author: lukaszsamson

apps/language_server/lib/language_server/mcp/request_handler.ex

@@ -616,31 +616,6 @@ defmodule ElixirLS.LanguageServer.MCP.RequestHandler do
     end
   end
 
-  defp format_function_doc(func) when is_binary(func) do
-    "- #{func}"
-  end
-
-  defp format_function_doc(func) when is_map(func) do
-    parts = ["### #{func.function}/#{func.arity}"]
-
-    parts =
-      if func[:specs] && length(func.specs) > 0 do
-        specs = Enum.join(func.specs, "\n")
-        parts ++ ["\n```elixir\n#{specs}\n```"]
-      else
-        parts
-      end
-
-    parts =
-      if func[:doc] do
-        parts ++ ["\n#{func.doc}"]
-      else
-        parts
-      end
-
-    Enum.join(parts, "\n")
-  end
-
   defp format_type_info_result(%{error: error}) do
     "Error: #{error}"
   end
@@ -994,10 +969,13 @@ defmodule ElixirLS.LanguageServer.MCP.RequestHandler do
     parts = ["# Environment Information"]
 
     # Location
-    if result[:location] do
-      location = result.location
-      parts = parts ++ ["\n**Location**: #{location.uri}:#{location.line}:#{location.column}"]
-    end
+    parts =
+      if result[:location] do
+        location = result.location
+        parts ++ ["\n**Location**: #{location.uri}:#{location.line}:#{location.column}"]
+      else
+        parts
+      end
 
     # Context
     parts =

apps/language_server/lib/language_server/providers/execute_command/llm_docs_aggregator.ex

@@ -171,7 +171,7 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
         docs when is_list(docs) ->
           docs
           |> Enum.filter(fn
-            {{^function, arity}, _anno, kind, _signatures, _doc, _metadata}
+            {{^function, _arity}, _anno, kind, _signatures, _doc, _metadata}
             when kind in [:function, :macro] ->
               true
 
@@ -191,7 +191,7 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
         specs when is_list(specs) ->
           specs
           |> Enum.filter(fn
-            {{^function, arity}, _} -> true
+            {{^function, _arity}, _} -> true
             _ -> false
           end)
           |> Enum.map(fn {{_name, arity}, _} -> arity end)
@@ -207,7 +207,7 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
         docs when is_list(docs) ->
           docs
           |> Enum.filter(fn
-            {{^function, arity}, _, _, _, _} -> true
+            {{^function, _arity}, _, _, _, _} -> true
             _ -> false
           end)
           |> Enum.map(fn {{_name, arity}, _, _, _, _} -> arity end)
@@ -223,7 +223,7 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
         types when is_list(types) ->
           types
           |> Enum.filter(fn
-            {kind, {^function, _, args}} when kind in [:type, :typep, :opaque] ->
+            {kind, {^function, _, _args}} when kind in [:type, :typep, :opaque] ->
               true
 
             _ ->
@@ -361,9 +361,9 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
             # Filter out module_info functions and other special functions
             functions =
               exports
-              |> Enum.filter(fn {name, arity} ->
-                name not in [:module_info, :__info__] and
-                  not String.starts_with?(Atom.to_string(name), "__")
+              |> Enum.filter(fn {name, _arity} ->
+                name not in [:module_info, :__info__, :behaviour_info] and
+                  not String.starts_with?(Atom.to_string(name), "_")
               end)
               |> Enum.map(fn {name, arity} ->
                 %{
@@ -394,7 +394,7 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
           |> Enum.map(fn doc -> format_type_doc(module, doc) end)
           |> Enum.reject(&is_nil/1)
 
-        other ->
+        _other ->
           []
       end
 
@@ -684,7 +684,7 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
       when kind in [:function, :macro] ->
         arity == nil or doc_arity == arity
 
-      _ = h ->
+      _ ->
         false
     end)
   end
@@ -808,40 +808,6 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDocsAggregator do
     _ -> []
   end
 
-  defp format_sections_as_list(sections) do
-    sections
-    |> Enum.flat_map(fn
-      %{type: "moduledoc", content: _content} ->
-        # Moduledoc is handled separately, not included in functions list
-        []
-
-      {:functions, functions} ->
-        Enum.map(functions, fn f ->
-          "#{f.function}/#{f.arity}"
-        end)
-
-      {:macros, macros} ->
-        Enum.map(macros, fn f ->
-          "#{f.function}/#{f.arity}"
-        end)
-
-      {:types, types} ->
-        Enum.map(types, fn f ->
-          "#{f.type}/#{f.arity}"
-        end)
-
-      {:callbacks, callbacks} ->
-        Enum.map(callbacks, fn f ->
-          "#{f.callback}/#{f.arity}"
-        end)
-
-      {:behaviours, behaviours} ->
-        Enum.map(behaviours, fn f ->
-          inspect(f.behaviour)
-        end)
-    end)
-  end
-
   defp extract_doc(%{"en" => doc}) when is_binary(doc), do: doc
   defp extract_doc(doc) when is_binary(doc), do: doc
   defp extract_doc(:none), do: nil

apps/language_server/lib/language_server/providers/execute_command/llm_environment.ex

@@ -374,14 +374,6 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmEnvironment do
     |> Enum.sort_by(& &1.name)
   end
 
-  defp format_types(types) do
-    types
-    |> Enum.map(fn {{module, name, arity}, _info} ->
-      "#{inspect(module)}.#{name}/#{arity}"
-    end)
-    |> Enum.sort()
-  end
-
   defp extract_modules_from_metadata(metadata = %ElixirSense.Core.Metadata{}) do
     metadata.mods_funs_to_positions
     |> Map.keys()
@@ -411,7 +403,7 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmEnvironment do
 
   defp format_callbacks_from_metadata(metadata) do
     metadata.specs
-    |> Enum.filter(fn {{_mod, fun, _}, %State.SpecInfo{} = info} ->
+    |> Enum.filter(fn {{_mod, _fun, _}, %State.SpecInfo{} = info} ->
       info.kind in [:callback, :macrocallback]
     end)
     |> Enum.map(fn {{mod, fun, arity}, _info} -> {mod, fun, arity} end)

apps/language_server/lib/language_server/providers/execute_command/llm_module_dependencies.ex

@@ -281,7 +281,7 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmModuleDependencies
     # Get all calls from this module
     calls =
       Tracer.get_trace()
-      |> Enum.filter(fn {{callee_module, _, _}, call_infos} ->
+      |> Enum.filter(fn {{callee_module, _, _}, _call_infos} ->
         # Check if the call is to our module
         callee_module == module
       end)

apps/language_server/test/providers/execute_command/llm_definition_test.exs

@@ -286,80 +286,5 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmDefinitionTest do
         assert {:ok, _} = result
       end
     end
-
-    test "handles builtin types using ElixirSense.Core.BuiltinTypes" do
-      # Test basic builtin types
-      basic_types = [
-        "atom",
-        "binary",
-        "boolean",
-        "integer",
-        "float",
-        "list",
-        "map",
-        "tuple",
-        "pid",
-        "port",
-        "reference",
-        "fun"
-      ]
-
-      for type <- basic_types do
-        result = LlmDefinition.execute([type], %{})
-        assert {:ok, response} = result
-        assert Map.has_key?(response, :definition)
-        assert response.definition =~ "Builtin type #{type}()"
-        assert response.definition =~ "@type"
-        assert response.definition =~ "Elixir built-in type"
-      end
-
-      # Test parameterized builtin types
-      result = LlmDefinition.execute(["list"], %{})
-      assert {:ok, response} = result
-      assert Map.has_key?(response, :definition)
-      # Should show both parameterized and non-parameterized versions
-      assert response.definition =~ "list()"
-
-      result = LlmDefinition.execute(["keyword"], %{})
-      assert {:ok, response} = result
-      assert Map.has_key?(response, :definition)
-      # Should show both parameterized and non-parameterized versions
-      assert response.definition =~ "keyword()"
-    end
-
-    test "handles various symbol patterns appropriately" do
-      # Some patterns that should result in errors or not-found
-      patterns_expecting_errors = [
-        "123StartWithNumber",
-        "::",
-        ".StartWithDot",
-        "EndWithDot.",
-        "Has-Dash"
-      ]
-
-      for pattern <- patterns_expecting_errors do
-        result = LlmDefinition.execute([pattern], %{})
-        assert {:ok, response} = result
-        # Should either be a parse error or "not found" error
-        assert Map.has_key?(response, :error) ||
-                 (Map.has_key?(response, :definition) && response.definition =~ "not found"),
-               "Expected error or not found for pattern: #{pattern}, got: #{inspect(response)}"
-      end
-
-      # Some patterns that the V2 parser may successfully parse (even if they look "invalid")
-      # but might not find definitions
-      potentially_parsable_patterns = [
-        "lower_case_module",
-        "Module.function/not_a_number",
-        "@attribute"
-      ]
-
-      for pattern <- potentially_parsable_patterns do
-        result = LlmDefinition.execute([pattern], %{})
-        assert {:ok, _response} = result
-        # These may succeed in parsing and either find a definition or return "not found"
-        # Both outcomes are acceptable with the V2 parser
-      end
-    end
   end
 end

apps/language_server/test/providers/references_test.exs

@@ -55,7 +55,7 @@ defmodule ElixirLS.LanguageServer.Providers.ReferencesTest do
     {line, char} =
       SourceFile.lsp_position_to_elixir(parser_context.source_file.text, {line, char})
 
-    list = References.references(parser_context, uri, line, char, true, File.cwd!())
+    list = References.references(parser_context, uri, line, char, false, File.cwd!())
 
     assert length(list) == 3
     assert Enum.any?(list, &(&1.uri |> String.ends_with?("references_remote.ex")))
@@ -78,7 +78,7 @@ defmodule ElixirLS.LanguageServer.Providers.ReferencesTest do
     {line, char} =
       SourceFile.lsp_position_to_elixir(parser_context.source_file.text, {line, char})
 
-    list = References.references(parser_context, uri, line, char, true, File.cwd!())
+    list = References.references(parser_context, uri, line, char, false, File.cwd!())
 
     assert length(list) == 3
     assert Enum.any?(list, &(&1.uri |> String.ends_with?("references_remote.ex")))
@@ -100,7 +100,7 @@ defmodule ElixirLS.LanguageServer.Providers.ReferencesTest do
     {line, char} =
       SourceFile.lsp_position_to_elixir(parser_context.source_file.text, {line, char})
 
-    assert References.references(parser_context, uri, line, char, true, File.cwd!()) == [
+    assert References.references(parser_context, uri, line, char, false, File.cwd!()) == [
              %GenLSP.Structures.Location{
                range: range(6, 4, 6, 16),
                uri: uri
@@ -122,7 +122,7 @@ defmodule ElixirLS.LanguageServer.Providers.ReferencesTest do
     {line, char} =
       SourceFile.lsp_position_to_elixir(parser_context.source_file.text, {line, char})
 
-    assert References.references(parser_context, uri, line, char, true, File.cwd!()) == [
+    assert References.references(parser_context, uri, line, char, false, File.cwd!()) == [
              %GenLSP.Structures.Location{
                range: range(10, 4, 10, 22),
                uri: uri
@@ -219,7 +219,7 @@ defmodule ElixirLS.LanguageServer.Providers.ReferencesTest do
     {line, char} =
       SourceFile.lsp_position_to_elixir(parser_context.source_file.text, {line, char})
 
-    list = References.references(parser_context, uri, line, char, true, File.cwd!())
+    list = References.references(parser_context, uri, line, char, false, File.cwd!())
 
     assert length(list) == 2
     assert Enum.any?(list, &(&1.uri |> String.ends_with?("references_erlang.ex")))
@@ -241,7 +241,7 @@ defmodule ElixirLS.LanguageServer.Providers.ReferencesTest do
     {line, char} =
       SourceFile.lsp_position_to_elixir(parser_context.source_file.text, {line, char})
 
-    list = References.references(parser_context, uri, line, char, true, File.cwd!())
+    list = References.references(parser_context, uri, line, char, false, File.cwd!())
 
     assert length(list) == 2
     assert Enum.any?(list, &(&1.uri |> String.ends_with?("references_erlang.ex")))

apps/language_server/test/server_test.exs

@@ -1795,7 +1795,7 @@ defmodule ElixirLS.LanguageServer.ServerTest do
 
       Server.receive_packet(
         server,
-        references_req(4, file_uri, 1, 8, true)
+        references_req(4, file_uri, 1, 8, false)
       )
 
       resp = assert_receive(%{"id" => 4}, 5000)
@@ -1829,7 +1829,7 @@ defmodule ElixirLS.LanguageServer.ServerTest do
 
       Server.receive_packet(
         server,
-        references_req(4, file_uri, 1, 9, true)
+        references_req(4, file_uri, 1, 9, false)
       )
 
       resp = assert_receive(%{"id" => 4}, 5000)