add helper functions for builtin type and function retrieval

Author: lukaszsamson

lib/elixir_sense/core/builtin_functions.ex

@@ -1,5 +1,6 @@
 defmodule ElixirSense.Core.BuiltinFunctions do
   @moduledoc false
+  require ElixirSense.Core.Introspection, as: Introspection
 
   @functions %{
     {:exception, 1} => %{specs: [quote(do: exception(term) :: Exception.t())], args: ["msg"]},
@@ -210,6 +211,43 @@ defmodule ElixirSense.Core.BuiltinFunctions do
 
   @all Map.keys(@functions)
 
+  @doc """
+  Returns a list of all builtin functions matching the given function name and arity.
+
+  ## Parameters
+    - function: The function name (atom or string)
+    - arity: The arity (integer) or :any for all arities
+    
+  ## Returns
+    A list of tuples {function_name, arity, doc, specs} for all matching functions.
+    
+  ## Examples
+    
+      iex> get_builtin_functions_doc(:module_info, :any)
+      [{"module_info", 0, "The `module_info/0` function...", ["@spec module_info() :: ..."]},
+       {"module_info", 1, "The call `module_info(Key)`...", ["@spec module_info(:module) :: ..."]}]
+      
+      iex> get_builtin_functions_doc(:module_info, 1)
+      [{"module_info", 1, "The call `module_info(Key)`...", ["@spec module_info(:module) :: ..."]}]
+      
+      iex> get_builtin_functions_doc(:module_info, 0)
+      [{"module_info", 0, "The `module_info/0` function...", ["@spec module_info() :: ..."]}]
+  """
+  def get_builtin_functions_doc(function, arity) do
+    function_atom = if is_atom(function), do: function, else: String.to_atom(to_string(function))
+
+    @functions
+    |> Enum.filter(fn {{f, a}, _value} ->
+      f == function_atom and Introspection.matches_arity?(a, arity)
+    end)
+    |> Enum.map(fn {{f, a}, %{specs: specs}} ->
+      doc = Map.get(@docs, {f, a}, "")
+      formatted_specs = specs |> Enum.map(&"@spec #{Macro.to_string(&1)}")
+      {to_string(f), a, doc, formatted_specs}
+    end)
+    |> Enum.sort_by(fn {_name, arity, _doc, _specs} -> arity end)
+  end
+
   for {{f, a}, %{specs: specs}} <- @functions do
     def get_specs({unquote(f), unquote(a)}),
       do: unquote(specs |> Enum.map(&"@spec #{Macro.to_string(&1)}"))

lib/elixir_sense/core/builtin_types.ex

@@ -1,5 +1,6 @@
 defmodule ElixirSense.Core.BuiltinTypes do
   @moduledoc false
+  require ElixirSense.Core.Introspection, as: Introspection
 
   @basic_types %{
     "any" => %{
@@ -257,6 +258,58 @@ defmodule ElixirSense.Core.BuiltinTypes do
     end
   end
 
+  @doc """
+  Returns a list of all builtin types matching the given type name and arity.
+
+  ## Parameters
+    - type: The type name (atom or string)
+    - arity: The arity (integer) or nil for all arities
+    
+  ## Returns
+    A list of tuples {type_name, arity, doc} for all matching types.
+    
+  ## Examples
+    
+      iex> get_builtin_types_doc(:list, :any)
+      [{"list", 0, "A list"}, {"list", 1, "Proper list ([]-terminated)"}]
+      
+      iex> get_builtin_types_doc(:list, 1)
+      [{"list", 1, "Proper list ([]-terminated)"}]
+      
+      iex> get_builtin_types_doc(:list, 0)
+      [{"list", 0, "A list"}]
+  """
+  def get_builtin_types_doc(type, arity) do
+    type_str = to_string(type)
+
+    @types
+    |> Enum.filter(fn {key, _value} ->
+      case String.split(key, "/") do
+        [^type_str] ->
+          # Type without arity (e.g., "list")
+          Introspection.matches_arity?(0, arity)
+
+        [^type_str, arity_str] ->
+          Introspection.matches_arity?(String.to_integer(arity_str), arity)
+
+        # Type with arity (e.g., "list/1")
+
+        _ ->
+          false
+      end
+    end)
+    |> Enum.map(fn {key, %{doc: doc}} ->
+      case String.split(key, "/") do
+        [type_name] ->
+          {type_name, 0, doc}
+
+        [type_name, arity_str] ->
+          {type_name, String.to_integer(arity_str), doc}
+      end
+    end)
+    |> Enum.sort_by(fn {_name, arity, _doc} -> arity end)
+  end
+
   def all do
     @types
   end