[WIP] Erlang Intellisense

lib/livebook/intellisense/elixir.ex

@@ -40,19 +40,24 @@ defmodule Livebook.Intellisense.Elixir do
   end
 
   defp handle_completion(hint, context, node) do
+    Intellisense.Elixir.IdentifierMatcher.completion_identifiers(hint, context, node)
+    |> format_completion_identifiers(extra_completion_items(hint))
+  end
+
+  def format_completion_identifiers(completions, extra \\ []) do
     items =
-      Intellisense.Elixir.IdentifierMatcher.completion_identifiers(hint, context, node)
+      completions
       |> Enum.filter(&include_in_completion?/1)
       |> Enum.map(&format_completion_item/1)
-      |> Enum.concat(extra_completion_items(hint))
+      |> Enum.concat(extra)
       |> Enum.sort_by(&completion_item_priority/1)
 
     %{items: items}
   end
 
-  defp include_in_completion?(%{kind: :module, documentation: :hidden}), do: false
-  defp include_in_completion?(%{kind: :function, documentation: :hidden}), do: false
-  defp include_in_completion?(_), do: true
+  def include_in_completion?(%{kind: :module, documentation: :hidden}), do: false
+  def include_in_completion?(%{kind: :function, documentation: :hidden}), do: false
+  def include_in_completion?(_), do: true
 
   defp format_completion_item(%{kind: :variable, name: name}),
     do: %{
@@ -133,6 +138,7 @@ defmodule Livebook.Intellisense.Elixir do
     }
   end
 
+  #TODO : module and signature is important in display of completion docs, name and displayname isnt in happy flow, if no signatures name is also needed
   defp format_completion_item(%{
          kind: :function,
          module: module,
@@ -192,14 +198,41 @@ defmodule Livebook.Intellisense.Elixir do
          insert_text:
            cond do
              arity == 0 -> "#{Atom.to_string(name)}()"
+             #
              true -> "#{Atom.to_string(name)}(${})"
            end
        }
 
+
+  # Note: array_needed is a boolean to know if '[]' should be put inside atrribute,
+  # as in -export([]). It is also a way to differentiate erlang's atributes from elixir's.
+  defp format_completion_item(%{
+    kind: :module_attribute,
+    name: name,
+    documentation: documentation,
+    array_needed: array_needed
+  }),
+  do: %{
+    label: Atom.to_string(name),
+    kind: :variable,
+    documentation:
+      join_with_newlines([
+        Intellisense.Elixir.Docs.format_documentation(documentation, :short),
+        "(module attribute)"
+      ]),
+    # A snippet with cursor in parentheses
+    insert_text:
+    if array_needed do
+      "#{name}([${}])."
+    else
+      "#{name}(${})."
+    end
+  }
+
   defp format_completion_item(%{
          kind: :module_attribute,
          name: name,
-         documentation: documentation
+         documentation: documentation,
        }),
        do: %{
          label: Atom.to_string(name),
@@ -212,6 +245,7 @@ defmodule Livebook.Intellisense.Elixir do
          insert_text: Atom.to_string(name)
        }
 
+
   defp format_completion_item(%{kind: :bitstring_modifier, name: name, arity: arity}) do
     insert_text =
       if arity == 0 do
@@ -228,7 +262,7 @@ defmodule Livebook.Intellisense.Elixir do
     }
   end
 
-  defp keyword_macro?(name) do
+  def keyword_macro?(name) do
     def? = name |> Atom.to_string() |> String.starts_with?("def")
 
     def? or
@@ -256,7 +290,7 @@ defmodule Livebook.Intellisense.Elixir do
       ]
   end
 
-  defp env_macro?(name) do
+  def env_macro?(name) do
     name in [:__ENV__, :__MODULE__, :__DIR__, :__STACKTRACE__, :__CALLER__]
   end
 
@@ -309,15 +343,15 @@ defmodule Livebook.Intellisense.Elixir do
     :bitstring_option
   ]
 
-  defp completion_item_priority(%{kind: :struct} = completion_item) do
+  def completion_item_priority(%{kind: :struct} = completion_item) do
     if completion_item.documentation =~ "(exception)" do
       {length(@ordered_kinds), completion_item.label}
     else
       {completion_item_kind_priority(completion_item.kind), completion_item.label}
     end
   end
 
-  defp completion_item_priority(completion_item) do
+  def completion_item_priority(completion_item) do
     {completion_item_kind_priority(completion_item.kind), completion_item.label}
   end
 
@@ -338,22 +372,21 @@ defmodule Livebook.Intellisense.Elixir do
         contents = Enum.map(matches, &format_details_item/1)
 
         definition = get_definition_location(hd(matches), context)
-
         %{range: range, contents: contents, definition: definition}
     end
   end
 
-  defp include_in_details?(%{kind: :function, from_default: true}), do: false
-  defp include_in_details?(%{kind: :bitstring_modifier}), do: false
-  defp include_in_details?(_), do: true
+  def include_in_details?(%{kind: :function, from_default: true}), do: false
+  def include_in_details?(%{kind: :bitstring_modifier}), do: false
+  def include_in_details?(_), do: true
 
-  defp format_details_item(%{kind: :variable, name: name}), do: code(name)
+  def format_details_item(%{kind: :variable, name: name}), do: code(name)
 
-  defp format_details_item(%{kind: :map_field, name: name}), do: code(name)
+  def format_details_item(%{kind: :map_field, name: name}), do: code(name)
 
-  defp format_details_item(%{kind: :in_map_field, name: name}), do: code(name)
+  def format_details_item(%{kind: :in_map_field, name: name}), do: code(name)
 
-  defp format_details_item(%{kind: :in_struct_field, name: name, default: default}) do
+  def format_details_item(%{kind: :in_struct_field, name: name, default: default}) do
     join_with_divider([
       code(name),
       """
@@ -366,15 +399,17 @@ defmodule Livebook.Intellisense.Elixir do
     ])
   end
 
-  defp format_details_item(%{kind: :module, module: module, documentation: documentation}) do
+  #TODO: module formatting should handle erlang modules too, module is of type :math and should be math
+  def format_details_item(%{kind: :module, module: module, documentation: documentation}) do
     join_with_divider([
       code(inspect(module)),
       format_docs_link(module),
       Intellisense.Elixir.Docs.format_documentation(documentation, :all)
     ])
   end
 
-  defp format_details_item(%{
+  #TODO: format_signatures and format_specs needs to be reworked for erlang functions
+  def format_details_item(%{
          kind: :function,
          module: module,
          name: name,
@@ -396,7 +431,7 @@ defmodule Livebook.Intellisense.Elixir do
     ])
   end
 
-  defp format_details_item(%{
+  def format_details_item(%{
          kind: :type,
          module: module,
          name: name,
@@ -412,38 +447,38 @@ defmodule Livebook.Intellisense.Elixir do
     ])
   end
 
-  defp format_details_item(%{kind: :module_attribute, name: name, documentation: documentation}) do
+  def format_details_item(%{kind: :module_attribute, name: name, documentation: documentation}) do
     join_with_divider([
       code("@#{name}"),
       Intellisense.Elixir.Docs.format_documentation(documentation, :all)
     ])
   end
 
-  defp get_definition_location(%{kind: :module, module: module}, context) do
+  def get_definition_location(%{kind: :module, module: module}, context) do
     get_definition_location(module, context, {:module, module})
   end
 
-  defp get_definition_location(
+  def get_definition_location(
          %{kind: :function, module: module, name: name, arity: arity},
          context
        ) do
     get_definition_location(module, context, {:function, name, arity})
   end
 
-  defp get_definition_location(%{kind: :type, module: module, name: name, arity: arity}, context) do
+  def get_definition_location(%{kind: :type, module: module, name: name, arity: arity}, context) do
     get_definition_location(module, context, {:type, name, arity})
   end
 
-  defp get_definition_location(_idenfitier, _context), do: nil
+  def get_definition_location(_idenfitier, _context), do: nil
 
-  defp get_definition_location(module, context, identifier) do
+  def get_definition_location(module, context, identifier) do
     if context.ebin_path do
       path = Path.join(context.ebin_path, "#{module}.beam")
 
       with true <- File.exists?(path),
            {:ok, line} <-
-             Intellisense.Elixir.Docs.locate_definition(String.to_charlist(path), identifier) do
-        file = module.module_info(:compile)[:source]
+             Intellisense.Elixir.Docs.locate_definition(String.to_charlist(path), identifier),
+           {:ok, file} <- Keyword.fetch(module.module_info(:compile), :source) do
         %{file: to_string(file), line: line}
       else
         _otherwise -> nil
@@ -470,7 +505,8 @@ defmodule Livebook.Intellisense.Elixir do
     end
   end
 
-  defp format_signature_item({_name, signature, _documentation, _specs}),
+  # FIXME: This is public
+  def format_signature_item({_name, signature, _documentation, _specs}),
     do: %{
       signature: signature,
       arguments: arguments_from_signature(signature)
@@ -485,30 +521,30 @@ defmodule Livebook.Intellisense.Elixir do
 
   # Formatting helpers
 
-  defp join_with_divider(strings), do: join_with(strings, "\n\n---\n\n")
+  def join_with_divider(strings), do: join_with(strings, "\n\n---\n\n")
 
-  defp join_with_newlines(strings), do: join_with(strings, "\n\n")
+  def join_with_newlines(strings), do: join_with(strings, "\n\n")
 
-  defp join_with_middle_dot(strings), do: join_with(strings, " · ")
+  def join_with_middle_dot(strings), do: join_with(strings, " · ")
 
-  defp join_with(strings, joiner) do
+  def join_with(strings, joiner) do
     case Enum.reject(strings, &is_nil/1) do
       [] -> nil
       parts -> Enum.join(parts, joiner)
     end
   end
 
-  defp code(nil), do: nil
+  def code(nil), do: nil
 
-  defp code(code) do
+  def code(code) do
     """
     ```
     #{code}
     ```\
     """
   end
 
-  defp format_docs_link(module, function_or_type \\ nil) do
+  def format_docs_link(module, function_or_type \\ nil) do
     app = Application.get_application(module)
     module_name = module_name(module)
 
@@ -558,6 +594,7 @@ defmodule Livebook.Intellisense.Elixir do
     signature_fallback(module, name, arity)
   end
 
+  #TODO: this should be reimplemented for erlang, module is of type :module, and . is used not :
   defp format_signatures(signatures, module, _name, _arity) do
     signatures_string = Enum.join(signatures, "\n")
 
@@ -583,15 +620,15 @@ defmodule Livebook.Intellisense.Elixir do
     "#{inspect(module)}.#{name}(#{args})"
   end
 
-  defp format_meta(:deprecated, %{deprecated: deprecated}) do
+  def format_meta(:deprecated, %{deprecated: deprecated}) do
     "**Deprecated**. " <> deprecated
   end
 
-  defp format_meta(:since, %{since: since}) do
+  def format_meta(:since, %{since: since}) do
     "Since " <> since
   end
 
-  defp format_meta(_, _), do: nil
+  def format_meta(_, _), do: nil
 
   defp format_specs([], _name, _line_length), do: nil
 

lib/livebook/intellisense/elixir/docs.ex

@@ -189,24 +189,48 @@ defmodule Livebook.Intellisense.Elixir.Docs do
   def locate_definition(path, identifier)
 
   def locate_definition(path, {:module, module}) do
-    with {:ok, {:raw_abstract_v1, annotations}} <- beam_lib_chunks(path, :abstract_code) do
-      {:attribute, anno, :module, ^module} =
-        Enum.find(annotations, &match?({:attribute, _, :module, _}, &1))
+    case beam_lib_chunks(path, :abstract_code) do
+      {:ok, {:raw_abstract_v1, annotations}} ->
+        {:attribute, anno, :module, ^module} =
+          Enum.find(annotations, &match?({:attribute, _, :module, _}, &1))
 
-      {:ok, :erl_anno.line(anno)}
+        {:ok, :erl_anno.line(anno)}
+
+      _ ->
+        :error
     end
   end
 
   def locate_definition(path, {:function, name, arity}) do
     with {:ok, {:debug_info_v1, _, {:elixir_v1, meta, _}}} <- beam_lib_chunks(path, :debug_info),
          {_pair, _kind, kw, _body} <- keyfind(meta.definitions, {name, arity}) do
       Keyword.fetch(kw, :line)
+    else
+      _ -> locate_erlang_function(path, name, arity)
     end
   end
 
   def locate_definition(path, {:type, name, arity}) do
-    with {:ok, {:raw_abstract_v1, annotations}} <- beam_lib_chunks(path, :abstract_code) do
-      fetch_type_line(annotations, name, arity)
+    case beam_lib_chunks(path, :abstract_code) do
+      {:ok, {:raw_abstract_v1, annotations}} ->
+        fetch_type_line(annotations, name, arity)
+
+      _ ->
+        :error
+    end
+  end
+
+  defp locate_erlang_function(path, name, arity) do
+    with {:ok, {:raw_abstract_v1, annotations}} <-
+           beam_lib_chunks(path, :abstract_code),
+         line when is_integer(line) <-
+           Enum.find_value(annotations, fn
+             {:function, anno, ^name, ^arity, _} -> :erl_anno.line(anno)
+             _ -> nil
+           end) do
+      {:ok, line}
+    else
+      _ -> :error
     end
   end