diff --git a/assets/js/hooks/cell_editor/live_editor.js b/assets/js/hooks/cell_editor/live_editor.js
index 00f4b7826..f3c61aa46 100644
--- a/assets/js/hooks/cell_editor/live_editor.js
+++ b/assets/js/hooks/cell_editor/live_editor.js
@@ -506,7 +506,9 @@ export default class LiveEditor {
     const settings = settingsStore.get();
 
     // Trigger completion implicitly only for identifiers and members
-    const triggerBeforeCursor = context.matchBefore(/[\w?!.]$/);
+    const triggerBeforeCursor = context.matchBefore(
+      this.getTriggerBeforeCursorRegex(),
+    );
 
     if (!triggerBeforeCursor && !context.explicit) {
       return null;
@@ -546,6 +548,13 @@ export default class LiveEditor {
       .catch(() => null);
   }
 
+  /** Get the regex for the trigger before cursor */
+  getTriggerBeforeCursorRegex() {
+    if (this.language === "elixir") return /[\w?!.]$/;
+    if (this.language === "erlang") return /[\w:]$/;
+    return /[\w.]$/;
+  }
+
   /** @private */
   getCompletionHint(context) {
     // By default we only send the current line content until cursor
diff --git a/lib/livebook/intellisense.ex b/lib/livebook/intellisense.ex
index b1aba292f..7d12d52a3 100644
--- a/lib/livebook/intellisense.ex
+++ b/lib/livebook/intellisense.ex
@@ -1,17 +1,12 @@
 defmodule Livebook.Intellisense do
-  # This module provides intellisense related operations suitable for
-  # integration with a text editor.
+  # Language-specific intellisense that is used by the code editor.
   #
-  # In a way, this provides the very basic features of a language
-  # server that Livebook uses.
+  # This module defines a behaviour and dispatches the intellisense
+  # implementation to the appropriate language-specific module.
 
   alias Livebook.Intellisense
   alias Livebook.Runtime
 
-  # Configures width used for inspect and specs formatting.
-  @line_length 45
-  @extended_line_length 80
-
   @typedoc """
   Evaluation state to consider for intellisense.
 
@@ -24,6 +19,35 @@ defmodule Livebook.Intellisense do
           map_binding: (Code.binding() -> any())
         }
 
+  @doc """
+  Language-specific implementation of `t:Runtime.intellisense_request/1`.
+  """
+  @callback handle_request(
+              request :: Runtime.intellisense_request(),
+              context :: context(),
+              node :: node()
+            ) :: Runtime.intellisense_response()
+
+  @doc """
+  Resolves an intellisense request as defined in
+  `t:Runtime.intellisense_request/1`.
+  """
+  @spec handle_request(
+          Runtime.language(),
+          Runtime.intellisense_request(),
+          context(),
+          node()
+        ) :: Runtime.intellisense_response()
+  def handle_request(language, request, context, node) do
+    if impl = impl_for_language(language) do
+      apply(impl, :handle_request, [request, context, node])
+    end
+  end
+
+  defp impl_for_language(:elixir), do: Intellisense.Elixir
+  defp impl_for_language(:erlang), do: Intellisense.Erlang
+  defp impl_for_language(_other), do: nil
+
   @doc """
   Adjusts the system for more accurate intellisense.
   """
@@ -57,896 +81,6 @@ defmodule Livebook.Intellisense do
   """
   @spec clear_cache(node()) :: :ok
   def clear_cache(node) do
-    Intellisense.IdentifierMatcher.clear_all_loaded(node)
-  end
-
-  @doc """
-  Resolves an intellisense request as defined by `Runtime`.
-
-  In practice this function simply dispatches the request to one of
-  the other public functions in this module.
-  """
-  @spec handle_request(
-          Runtime.intellisense_request(),
-          context(),
-          node()
-        ) :: Runtime.intellisense_response()
-  def handle_request(request, context, node)
-
-  def handle_request({:completion, hint}, context, node) do
-    items = get_completion_items(hint, context, node)
-    %{items: items}
-  end
-
-  def handle_request({:details, line, column}, context, node) do
-    get_details(line, column, context, node)
-  end
-
-  def handle_request({:signature, hint}, context, node) do
-    get_signature_items(hint, context, node)
-  end
-
-  def handle_request({:format, code}, _context, _node) do
-    format_code(code)
-  end
-
-  @doc """
-  Formats Elixir code.
-  """
-  @spec format_code(String.t()) :: Runtime.format_response()
-  def format_code(code) do
-    try do
-      formatted =
-        code
-        |> Code.format_string!()
-        |> IO.iodata_to_binary()
-
-      %{code: formatted, code_markers: []}
-    rescue
-      error in [SyntaxError, TokenMissingError, MismatchedDelimiterError] ->
-        code_marker = %{line: error.line, description: error.description, severity: :error}
-        %{code: nil, code_markers: [code_marker]}
-    end
-  end
-
-  @doc """
-  Returns information about signatures matching the given `hint`.
-  """
-  @spec get_signature_items(String.t(), context(), node()) :: Runtime.signature_response() | nil
-  def get_signature_items(hint, context, node) do
-    case Intellisense.SignatureMatcher.get_matching_signatures(hint, context, node) do
-      {:ok, [], _active_argument} ->
-        nil
-
-      {:ok, signature_infos, active_argument} ->
-        %{
-          active_argument: active_argument,
-          items:
-            signature_infos
-            |> Enum.map(&format_signature_item/1)
-            |> Enum.uniq()
-        }
-
-      :error ->
-        nil
-    end
-  end
-
-  defp format_signature_item({_name, signature, _documentation, _specs}),
-    do: %{
-      signature: signature,
-      arguments: arguments_from_signature(signature)
-    }
-
-  defp arguments_from_signature(signature) do
-    signature
-    |> Code.string_to_quoted!()
-    |> elem(2)
-    |> Enum.map(&Macro.to_string/1)
-  end
-
-  @doc """
-  Returns a list of completion suggestions for the given `hint`.
-  """
-  @spec get_completion_items(String.t(), context(), node()) :: list(Runtime.completion_item())
-  def get_completion_items(hint, context, node) do
-    Intellisense.IdentifierMatcher.completion_identifiers(hint, context, node)
-    |> Enum.filter(&include_in_completion?/1)
-    |> Enum.map(&format_completion_item/1)
-    |> Enum.concat(extra_completion_items(hint))
-    |> Enum.sort_by(&completion_item_priority/1)
-  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
-
-  defp format_completion_item(%{kind: :variable, name: name}),
-    do: %{
-      label: Atom.to_string(name),
-      kind: :variable,
-      documentation: "(variable)",
-      insert_text: Atom.to_string(name)
-    }
-
-  defp format_completion_item(%{kind: :map_field, name: name}),
-    do: %{
-      label: Atom.to_string(name),
-      kind: :field,
-      documentation: "(field)",
-      insert_text: Atom.to_string(name)
-    }
-
-  defp format_completion_item(%{kind: :in_map_field, name: name}),
-    do: %{
-      label: Atom.to_string(name),
-      kind: :field,
-      documentation: "(field)",
-      insert_text: "#{name}: "
-    }
-
-  defp format_completion_item(%{
-         kind: :in_struct_field,
-         struct: struct,
-         name: name,
-         default: default
-       }),
-       do: %{
-         label: Atom.to_string(name),
-         kind: :field,
-         documentation:
-           join_with_divider([
-             """
-             `%#{inspect(struct)}{}` struct field.
-
-             **Default**
-
-             ```
-             #{inspect(default, pretty: true, width: @line_length)}
-             ```\
-             """
-           ]),
-         insert_text: "#{name}: "
-       }
-
-  defp format_completion_item(%{
-         kind: :module,
-         module: module,
-         display_name: display_name,
-         documentation: documentation
-       }) do
-    subtype = Intellisense.Docs.get_module_subtype(module)
-
-    kind =
-      case subtype do
-        :protocol -> :interface
-        :exception -> :struct
-        :struct -> :struct
-        :behaviour -> :interface
-        _ -> :module
-      end
-
-    detail = Atom.to_string(subtype || :module)
-
-    %{
-      label: display_name,
-      kind: kind,
-      documentation:
-        join_with_newlines([
-          format_documentation(documentation, :short),
-          "(#{detail})"
-        ]),
-      insert_text: String.trim_leading(display_name, ":")
-    }
-  end
-
-  defp format_completion_item(%{
-         kind: :function,
-         module: module,
-         name: name,
-         arity: arity,
-         type: type,
-         display_name: display_name,
-         documentation: documentation,
-         signatures: signatures
-       }),
-       do: %{
-         label: "#{display_name}/#{arity}",
-         kind: :function,
-         documentation:
-           join_with_newlines([
-             format_documentation(documentation, :short),
-             code(format_signatures(signatures, module, name, arity))
-           ]),
-         insert_text:
-           cond do
-             type == :macro and keyword_macro?(name) ->
-               "#{display_name} "
-
-             type == :macro and env_macro?(name) ->
-               display_name
-
-             String.starts_with?(display_name, "~") ->
-               display_name
-
-             Macro.operator?(name, arity) ->
-               display_name
-
-             arity == 0 ->
-               "#{display_name}()"
-
-             true ->
-               # A snippet with cursor in parentheses
-               "#{display_name}(${})"
-           end
-       }
-
-  defp format_completion_item(%{
-         kind: :type,
-         name: name,
-         arity: arity,
-         documentation: documentation,
-         type_spec: type_spec
-       }),
-       do: %{
-         label: "#{name}/#{arity}",
-         kind: :type,
-         documentation:
-           join_with_newlines([
-             format_documentation(documentation, :short),
-             format_type_spec(type_spec, @line_length) |> code()
-           ]),
-         insert_text:
-           cond do
-             arity == 0 -> "#{Atom.to_string(name)}()"
-             true -> "#{Atom.to_string(name)}(${})"
-           end
-       }
-
-  defp format_completion_item(%{
-         kind: :module_attribute,
-         name: name,
-         documentation: documentation
-       }),
-       do: %{
-         label: Atom.to_string(name),
-         kind: :variable,
-         documentation:
-           join_with_newlines([
-             format_documentation(documentation, :short),
-             "(module attribute)"
-           ]),
-         insert_text: Atom.to_string(name)
-       }
-
-  defp format_completion_item(%{kind: :bitstring_modifier, name: name, arity: arity}) do
-    insert_text =
-      if arity == 0 do
-        Atom.to_string(name)
-      else
-        "#{name}(${})"
-      end
-
-    %{
-      label: Atom.to_string(name),
-      kind: :type,
-      documentation: "(bitstring option)",
-      insert_text: insert_text
-    }
-  end
-
-  defp keyword_macro?(name) do
-    def? = name |> Atom.to_string() |> String.starts_with?("def")
-
-    def? or
-      name in [
-        # Special forms
-        :alias,
-        :case,
-        :cond,
-        :for,
-        :fn,
-        :import,
-        :quote,
-        :receive,
-        :require,
-        :try,
-        :with,
-
-        # Kernel
-        :destructure,
-        :raise,
-        :reraise,
-        :if,
-        :unless,
-        :use
-      ]
-  end
-
-  defp env_macro?(name) do
-    name in [:__ENV__, :__MODULE__, :__DIR__, :__STACKTRACE__, :__CALLER__]
-  end
-
-  defp extra_completion_items(hint) do
-    items = [
-      %{
-        label: "true",
-        kind: :keyword,
-        documentation: "(boolean)",
-        insert_text: "true"
-      },
-      %{
-        label: "false",
-        kind: :keyword,
-        documentation: "(boolean)",
-        insert_text: "false"
-      },
-      %{
-        label: "nil",
-        kind: :keyword,
-        documentation: "(special atom)",
-        insert_text: "nil"
-      },
-      %{
-        label: "when",
-        kind: :keyword,
-        documentation: "(guard operator)",
-        insert_text: "when"
-      }
-    ]
-
-    last_word = hint |> String.split(~r/\s/) |> List.last()
-
-    if last_word == "" do
-      []
-    else
-      Enum.filter(items, &String.starts_with?(&1.label, last_word))
-    end
-  end
-
-  @ordered_kinds [
-    :keyword,
-    :field,
-    :variable,
-    :module,
-    :struct,
-    :interface,
-    :function,
-    :type,
-    :bitstring_option
-  ]
-
-  defp 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
-    {completion_item_kind_priority(completion_item.kind), completion_item.label}
-  end
-
-  defp completion_item_kind_priority(kind) when kind in @ordered_kinds do
-    Enum.find_index(@ordered_kinds, &(&1 == kind))
-  end
-
-  @doc """
-  Returns detailed information about an identifier located
-  in `column` in `line`.
-  """
-  @spec get_details(String.t(), pos_integer(), context(), node()) ::
-          Runtime.details_response() | nil
-  def get_details(line, column, context, node) do
-    %{matches: matches, range: range} =
-      Intellisense.IdentifierMatcher.locate_identifier(line, column, context, node)
-
-    case Enum.filter(matches, &include_in_details?/1) do
-      [] ->
-        nil
-
-      matches ->
-        matches = Enum.sort_by(matches, & &1[:arity], :asc)
-        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
-
-  defp format_details_item(%{kind: :variable, name: name}), do: code(name)
-
-  defp format_details_item(%{kind: :map_field, name: name}), do: code(name)
-
-  defp 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
-    join_with_divider([
-      code(name),
-      """
-      **Default**
-
-      ```
-      #{inspect(default, pretty: true, width: @line_length)}
-      ```\
-      """
-    ])
-  end
-
-  defp format_details_item(%{kind: :module, module: module, documentation: documentation}) do
-    join_with_divider([
-      code(inspect(module)),
-      format_docs_link(module),
-      format_documentation(documentation, :all)
-    ])
-  end
-
-  defp format_details_item(%{
-         kind: :function,
-         module: module,
-         name: name,
-         arity: arity,
-         documentation: documentation,
-         signatures: signatures,
-         specs: specs,
-         meta: meta
-       }) do
-    join_with_divider([
-      format_signatures(signatures, module, name, arity) |> code(),
-      join_with_middle_dot([
-        format_docs_link(module, {:function, name, arity}),
-        format_meta(:since, meta)
-      ]),
-      format_meta(:deprecated, meta),
-      format_specs(specs, name, @extended_line_length) |> code(),
-      format_documentation(documentation, :all)
-    ])
-  end
-
-  defp format_details_item(%{
-         kind: :type,
-         module: module,
-         name: name,
-         arity: arity,
-         documentation: documentation,
-         type_spec: type_spec
-       }) do
-    join_with_divider([
-      format_type_signature(type_spec, module, name, arity) |> code(),
-      format_docs_link(module, {:type, name, arity}),
-      format_type_spec(type_spec, @extended_line_length) |> code(),
-      format_documentation(documentation, :all)
-    ])
-  end
-
-  defp format_details_item(%{kind: :module_attribute, name: name, documentation: documentation}) do
-    join_with_divider([
-      code("@#{name}"),
-      format_documentation(documentation, :all)
-    ])
-  end
-
-  defp get_definition_location(%{kind: :module, module: module}, context) do
-    get_definition_location(module, context, {:module, module})
-  end
-
-  defp 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
-    get_definition_location(module, context, {:type, name, arity})
-  end
-
-  defp get_definition_location(_idenfitier, _context), do: nil
-
-  defp 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.Docs.locate_definition(String.to_charlist(path), identifier) do
-        file = module.module_info(:compile)[:source]
-        %{file: to_string(file), line: line}
-      else
-        _otherwise -> nil
-      end
-    end
-  end
-
-  # Formatting helpers
-
-  defp join_with_divider(strings), do: join_with(strings, "\n\n---\n\n")
-
-  defp join_with_newlines(strings), do: join_with(strings, "\n\n")
-
-  defp join_with_middle_dot(strings), do: join_with(strings, " · ")
-
-  defp 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
-
-  defp code(code) do
-    """
-    ```
-    #{code}
-    ```\
-    """
-  end
-
-  defp format_docs_link(module, function_or_type \\ nil) do
-    app = Application.get_application(module)
-    module_name = module_name(module)
-
-    is_otp? =
-      case :code.which(module) do
-        :preloaded -> true
-        [_ | _] = path -> List.starts_with?(path, :code.lib_dir())
-        _ -> false
-      end
-
-    cond do
-      is_otp? ->
-        hash =
-          case function_or_type do
-            {:function, function, arity} -> "##{function}-#{arity}"
-            {:type, type, _arity} -> "#type-#{type}"
-            nil -> ""
-          end
-
-        url = "https://www.erlang.org/doc/man/#{module_name}.html#{hash}"
-        "[View on Erlang Docs](#{url})"
-
-      vsn = app && Application.spec(app, :vsn) ->
-        hash =
-          case function_or_type do
-            {:function, function, arity} -> "##{function}/#{arity}"
-            {:type, type, arity} -> "#t:#{type}/#{arity}"
-            nil -> ""
-          end
-
-        url = "https://hexdocs.pm/#{app}/#{vsn}/#{module_name}.html#{hash}"
-        "[View on Hexdocs](#{url})"
-
-      true ->
-        nil
-    end
-  end
-
-  defp format_signatures([], module, name, arity) do
-    signature_fallback(module, name, arity)
-  end
-
-  defp format_signatures(signatures, module, _name, _arity) do
-    signatures_string = Enum.join(signatures, "\n")
-
-    # Don't add module prefix to operator signatures
-    if :binary.match(signatures_string, ["(", "/"]) != :nomatch do
-      inspect(module) <> "." <> signatures_string
-    else
-      signatures_string
-    end
-  end
-
-  defp format_type_signature(nil, module, name, arity) do
-    signature_fallback(module, name, arity)
-  end
-
-  defp format_type_signature({_type_kind, type}, module, _name, _arity) do
-    {:"::", _env, [lhs, _rhs]} = Code.Typespec.type_to_quoted(type)
-    inspect(module) <> "." <> Macro.to_string(lhs)
-  end
-
-  defp signature_fallback(module, name, arity) do
-    args = Enum.map_join(1..arity//1, ", ", fn n -> "arg#{n}" end)
-    "#{inspect(module)}.#{name}(#{args})"
-  end
-
-  defp format_meta(:deprecated, %{deprecated: deprecated}) do
-    "**Deprecated**. " <> deprecated
-  end
-
-  defp format_meta(:since, %{since: since}) do
-    "Since " <> since
-  end
-
-  defp format_meta(_, _), do: nil
-
-  defp format_specs([], _name, _line_length), do: nil
-
-  defp format_specs(specs, name, line_length) do
-    spec_lines =
-      Enum.map(specs, fn spec ->
-        code = Code.Typespec.spec_to_quoted(name, spec) |> Macro.to_string()
-        ["@spec ", code]
-      end)
-
-    specs_code =
-      spec_lines
-      |> Enum.intersperse("\n")
-      |> IO.iodata_to_binary()
-
-    try do
-      Code.format_string!(specs_code, line_length: line_length)
-    rescue
-      _ -> specs_code
-    end
-  end
-
-  defp format_type_spec({type_kind, type}, line_length) when type_kind in [:type, :opaque] do
-    ast = {:"::", _env, [lhs, _rhs]} = Code.Typespec.type_to_quoted(type)
-
-    type_string =
-      case type_kind do
-        :type -> ast
-        :opaque -> lhs
-      end
-      |> Macro.to_string()
-
-    type_spec_code = "@#{type_kind} #{type_string}"
-
-    try do
-      Code.format_string!(type_spec_code, line_length: line_length)
-    rescue
-      _ -> type_spec_code
-    end
-  end
-
-  defp format_type_spec(_, _line_length), do: nil
-
-  defp format_documentation(doc, variant)
-
-  defp format_documentation(nil, _variant) do
-    "No documentation available"
-  end
-
-  defp format_documentation(:hidden, _variant) do
-    "This is a private API"
-  end
-
-  defp format_documentation({"text/markdown", markdown}, :short) do
-    # Extract just the first paragraph
-    markdown
-    |> String.split("\n\n")
-    |> hd()
-    |> String.trim()
-  end
-
-  defp format_documentation({"application/erlang+html", erlang_html}, :short) do
-    # Extract just the first paragraph
-    erlang_html
-    |> Enum.find(&match?({:p, _, _}, &1))
-    |> case do
-      nil -> nil
-      paragraph -> erlang_html_to_md([paragraph])
-    end
-  end
-
-  defp format_documentation({"text/markdown", markdown}, :all) do
-    markdown
-  end
-
-  defp format_documentation({"application/erlang+html", erlang_html}, :all) do
-    erlang_html_to_md(erlang_html)
-  end
-
-  defp format_documentation({format, _content}, _variant) do
-    raise "unknown documentation format #{inspect(format)}"
-  end
-
-  # Erlang HTML AST
-  # See https://erlang.org/doc/apps/erl_docgen/doc_storage.html#erlang-documentation-format
-
-  def erlang_html_to_md(ast) do
-    build_md([], ast)
-    |> IO.iodata_to_binary()
-    |> String.trim()
-  end
-
-  defp build_md(iodata, ast)
-
-  defp build_md(iodata, []), do: iodata
-
-  defp build_md(iodata, [string | ast]) when is_binary(string) do
-    string |> append_inline(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{tag, _, content} | ast]) when tag in [:em, :i] do
-    render_emphasis(content) |> append_inline(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{tag, _, content} | ast]) when tag in [:strong, :b] do
-    render_strong(content) |> append_inline(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{:code, _, content} | ast]) do
-    render_code_inline(content) |> append_inline(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{:a, attrs, content} | ast]) do
-    render_link(content, attrs) |> append_inline(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{:br, _, []} | ast]) do
-    render_line_break() |> append_inline(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{tag, _, content} | ast]) when tag in [:p, :div] do
-    render_paragraph(content) |> append_block(iodata) |> build_md(ast)
-  end
-
-  @headings ~w(h1 h2 h3 h4 h5 h6)a
-
-  defp build_md(iodata, [{tag, _, content} | ast]) when tag in @headings do
-    n = 1 + Enum.find_index(@headings, &(&1 == tag))
-    render_heading(n, content) |> append_block(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{:pre, _, [{:code, _, [content]}]} | ast]) do
-    render_code_block(content, "erlang") |> append_block(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{:div, [{:class, class} | _], content} | ast]) do
-    type = class |> to_string() |> String.upcase()
-
-    render_blockquote([{:p, [], [{:strong, [], [type]}]} | content])
-    |> append_block(iodata)
-    |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{:ul, [{:class, "types"} | _], content} | ast]) do
-    render_types_list(content) |> append_block(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{:ul, _, content} | ast]) do
-    render_unordered_list(content) |> append_block(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{:ol, _, content} | ast]) do
-    render_ordered_list(content) |> append_block(iodata) |> build_md(ast)
-  end
-
-  defp build_md(iodata, [{:dl, _, content} | ast]) do
-    render_description_list(content) |> append_block(iodata) |> build_md(ast)
-  end
-
-  defp append_inline(md, iodata), do: [iodata, md]
-  defp append_block(md, iodata), do: [iodata, "\n", md, "\n"]
-
-  # Renderers
-
-  defp render_emphasis(content) do
-    ["*", build_md([], content), "*"]
-  end
-
-  defp render_strong(content) do
-    ["**", build_md([], content), "**"]
-  end
-
-  defp render_code_inline(content) do
-    ["`", build_md([], content), "`"]
-  end
-
-  defp render_link(content, attrs) do
-    caption = build_md([], content)
-
-    if href = attrs[:href] do
-      ["[", caption, "](", href, ")"]
-    else
-      caption
-    end
-  end
-
-  defp render_line_break(), do: "\\\n"
-
-  defp render_paragraph(content), do: erlang_html_to_md(content)
-
-  defp render_heading(n, content) do
-    title = build_md([], content)
-    [String.duplicate("#", n), " ", title]
-  end
-
-  defp render_code_block(content, language) do
-    ["```", language, "\n", content, "\n```"]
-  end
-
-  defp render_blockquote(content) do
-    inner = erlang_html_to_md(content)
-
-    inner
-    |> String.split("\n")
-    |> Enum.map_intersperse("\n", &["> ", &1])
-  end
-
-  defp render_unordered_list(content) do
-    marker_fun = fn _index -> "* " end
-    render_list(content, marker_fun, "  ")
-  end
-
-  defp render_ordered_list(content) do
-    marker_fun = fn index -> "#{index + 1}. " end
-    render_list(content, marker_fun, "   ")
-  end
-
-  defp render_list(items, marker_fun, indent) do
-    spaced? = spaced_list_items?(items)
-    item_separator = if(spaced?, do: "\n\n", else: "\n")
-
-    items
-    |> Enum.map(fn {:li, _, content} -> erlang_html_to_md(content) end)
-    |> Enum.with_index()
-    |> Enum.map(fn {inner, index} ->
-      [first_line | lines] = String.split(inner, "\n")
-
-      first_line = marker_fun.(index) <> first_line
-
-      lines =
-        Enum.map(lines, fn
-          "" -> ""
-          line -> indent <> line
-        end)
-
-      Enum.intersperse([first_line | lines], "\n")
-    end)
-    |> Enum.intersperse(item_separator)
-  end
-
-  defp spaced_list_items?([{:li, _, [{:p, _, _content} | _]} | _items]), do: true
-  defp spaced_list_items?([_ | items]), do: spaced_list_items?(items)
-  defp spaced_list_items?([]), do: false
-
-  defp render_description_list(content) do
-    # Rewrite description list as an unordered list with pseudo heading
-    content
-    |> Enum.chunk_every(2)
-    |> Enum.map(fn [{:dt, _, dt}, {:dd, _, dd}] ->
-      {:li, [], [{:p, [], [{:strong, [], dt}]}, {:p, [], dd}]}
-    end)
-    |> render_unordered_list()
-  end
-
-  defp render_types_list(content) do
-    content
-    |> group_type_list_items([])
-    |> render_unordered_list()
-  end
-
-  defp group_type_list_items([], acc), do: Enum.reverse(acc)
-
-  defp group_type_list_items([{:li, [{:name, _type_name}], []} | items], acc) do
-    group_type_list_items(items, acc)
-  end
-
-  defp group_type_list_items([{:li, [{:class, "type"}], content} | items], acc) do
-    group_type_list_items(items, [{:li, [], [{:code, [], content}]} | acc])
-  end
-
-  defp group_type_list_items(
-         [{:li, [{:class, "description"}], content} | items],
-         [{:li, [], prev_content} | acc]
-       ) do
-    group_type_list_items(items, [{:li, [], prev_content ++ [{:p, [], content}]} | acc])
-  end
-
-  defp module_name(module) do
-    case Atom.to_string(module) do
-      "Elixir." <> name -> name
-      name -> name
-    end
+    Intellisense.Elixir.IdentifierMatcher.clear_all_loaded(node)
   end
 end
diff --git a/lib/livebook/intellisense/elixir.ex b/lib/livebook/intellisense/elixir.ex
new file mode 100644
index 000000000..f1ee0b1cd
--- /dev/null
+++ b/lib/livebook/intellisense/elixir.ex
@@ -0,0 +1,637 @@
+defmodule Livebook.Intellisense.Elixir do
+  alias Livebook.Intellisense
+
+  @behaviour Intellisense
+
+  # Configures width used for inspect and specs formatting.
+  @line_length 45
+  @extended_line_length 80
+
+  @impl true
+  def handle_request({:format, code}, _context, _node) do
+    handle_format(code)
+  end
+
+  def handle_request({:completion, hint}, context, node) do
+    handle_completion(hint, context, node)
+  end
+
+  def handle_request({:details, line, column}, context, node) do
+    handle_details(line, column, context, node)
+  end
+
+  def handle_request({:signature, hint}, context, node) do
+    handle_signature(hint, context, node)
+  end
+
+  defp handle_format(code) do
+    try do
+      formatted =
+        code
+        |> Code.format_string!()
+        |> IO.iodata_to_binary()
+
+      %{code: formatted, code_markers: []}
+    rescue
+      error in [SyntaxError, TokenMissingError, MismatchedDelimiterError] ->
+        code_marker = %{line: error.line, description: error.description, severity: :error}
+        %{code: nil, code_markers: [code_marker]}
+    end
+  end
+
+  defp handle_completion(hint, context, node) do
+    items =
+      Intellisense.Elixir.IdentifierMatcher.completion_identifiers(hint, context, node)
+      |> Enum.filter(&include_in_completion?/1)
+      |> Enum.map(&format_completion_item/1)
+      |> Enum.concat(extra_completion_items(hint))
+      |> 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
+
+  defp format_completion_item(%{kind: :variable, name: name}),
+    do: %{
+      label: Atom.to_string(name),
+      kind: :variable,
+      documentation: "(variable)",
+      insert_text: Atom.to_string(name)
+    }
+
+  defp format_completion_item(%{kind: :map_field, name: name}),
+    do: %{
+      label: Atom.to_string(name),
+      kind: :field,
+      documentation: "(field)",
+      insert_text: Atom.to_string(name)
+    }
+
+  defp format_completion_item(%{kind: :in_map_field, name: name}),
+    do: %{
+      label: Atom.to_string(name),
+      kind: :field,
+      documentation: "(field)",
+      insert_text: "#{name}: "
+    }
+
+  defp format_completion_item(%{
+         kind: :in_struct_field,
+         struct: struct,
+         name: name,
+         default: default
+       }),
+       do: %{
+         label: Atom.to_string(name),
+         kind: :field,
+         documentation:
+           join_with_divider([
+             """
+             `%#{inspect(struct)}{}` struct field.
+
+             **Default**
+
+             ```
+             #{inspect(default, pretty: true, width: @line_length)}
+             ```\
+             """
+           ]),
+         insert_text: "#{name}: "
+       }
+
+  defp format_completion_item(%{
+         kind: :module,
+         module: module,
+         display_name: display_name,
+         documentation: documentation
+       }) do
+    subtype = Intellisense.Elixir.Docs.get_module_subtype(module)
+
+    kind =
+      case subtype do
+        :protocol -> :interface
+        :exception -> :struct
+        :struct -> :struct
+        :behaviour -> :interface
+        _ -> :module
+      end
+
+    detail = Atom.to_string(subtype || :module)
+
+    %{
+      label: display_name,
+      kind: kind,
+      documentation:
+        join_with_newlines([
+          Intellisense.Elixir.Docs.format_documentation(documentation, :short),
+          "(#{detail})"
+        ]),
+      insert_text: String.trim_leading(display_name, ":")
+    }
+  end
+
+  defp format_completion_item(%{
+         kind: :function,
+         module: module,
+         name: name,
+         arity: arity,
+         type: type,
+         display_name: display_name,
+         documentation: documentation,
+         signatures: signatures
+       }),
+       do: %{
+         label: "#{display_name}/#{arity}",
+         kind: :function,
+         documentation:
+           join_with_newlines([
+             Intellisense.Elixir.Docs.format_documentation(documentation, :short),
+             code(format_signatures(signatures, module, name, arity))
+           ]),
+         insert_text:
+           cond do
+             type == :macro and keyword_macro?(name) ->
+               "#{display_name} "
+
+             type == :macro and env_macro?(name) ->
+               display_name
+
+             String.starts_with?(display_name, "~") ->
+               display_name
+
+             Macro.operator?(name, arity) ->
+               display_name
+
+             arity == 0 ->
+               "#{display_name}()"
+
+             true ->
+               # A snippet with cursor in parentheses
+               "#{display_name}(${})"
+           end
+       }
+
+  defp format_completion_item(%{
+         kind: :type,
+         name: name,
+         arity: arity,
+         documentation: documentation,
+         type_spec: type_spec
+       }),
+       do: %{
+         label: "#{name}/#{arity}",
+         kind: :type,
+         documentation:
+           join_with_newlines([
+             Intellisense.Elixir.Docs.format_documentation(documentation, :short),
+             format_type_spec(type_spec, @line_length) |> code()
+           ]),
+         insert_text:
+           cond do
+             arity == 0 -> "#{Atom.to_string(name)}()"
+             true -> "#{Atom.to_string(name)}(${})"
+           end
+       }
+
+  defp format_completion_item(%{
+         kind: :module_attribute,
+         name: name,
+         documentation: documentation
+       }),
+       do: %{
+         label: Atom.to_string(name),
+         kind: :variable,
+         documentation:
+           join_with_newlines([
+             Intellisense.Elixir.Docs.format_documentation(documentation, :short),
+             "(module attribute)"
+           ]),
+         insert_text: Atom.to_string(name)
+       }
+
+  defp format_completion_item(%{kind: :bitstring_modifier, name: name, arity: arity}) do
+    insert_text =
+      if arity == 0 do
+        Atom.to_string(name)
+      else
+        "#{name}(${})"
+      end
+
+    %{
+      label: Atom.to_string(name),
+      kind: :type,
+      documentation: "(bitstring option)",
+      insert_text: insert_text
+    }
+  end
+
+  defp keyword_macro?(name) do
+    def? = name |> Atom.to_string() |> String.starts_with?("def")
+
+    def? or
+      name in [
+        # Special forms
+        :alias,
+        :case,
+        :cond,
+        :for,
+        :fn,
+        :import,
+        :quote,
+        :receive,
+        :require,
+        :try,
+        :with,
+
+        # Kernel
+        :destructure,
+        :raise,
+        :reraise,
+        :if,
+        :unless,
+        :use
+      ]
+  end
+
+  defp env_macro?(name) do
+    name in [:__ENV__, :__MODULE__, :__DIR__, :__STACKTRACE__, :__CALLER__]
+  end
+
+  defp extra_completion_items(hint) do
+    items = [
+      %{
+        label: "true",
+        kind: :keyword,
+        documentation: "(boolean)",
+        insert_text: "true"
+      },
+      %{
+        label: "false",
+        kind: :keyword,
+        documentation: "(boolean)",
+        insert_text: "false"
+      },
+      %{
+        label: "nil",
+        kind: :keyword,
+        documentation: "(special atom)",
+        insert_text: "nil"
+      },
+      %{
+        label: "when",
+        kind: :keyword,
+        documentation: "(guard operator)",
+        insert_text: "when"
+      }
+    ]
+
+    last_word = hint |> String.split(~r/\s/) |> List.last()
+
+    if last_word == "" do
+      []
+    else
+      Enum.filter(items, &String.starts_with?(&1.label, last_word))
+    end
+  end
+
+  @ordered_kinds [
+    :keyword,
+    :field,
+    :variable,
+    :module,
+    :struct,
+    :interface,
+    :function,
+    :type,
+    :bitstring_option
+  ]
+
+  defp 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
+    {completion_item_kind_priority(completion_item.kind), completion_item.label}
+  end
+
+  defp completion_item_kind_priority(kind) when kind in @ordered_kinds do
+    Enum.find_index(@ordered_kinds, &(&1 == kind))
+  end
+
+  defp handle_details(line, column, context, node) do
+    %{matches: matches, range: range} =
+      Intellisense.Elixir.IdentifierMatcher.locate_identifier(line, column, context, node)
+
+    case Enum.filter(matches, &include_in_details?/1) do
+      [] ->
+        nil
+
+      matches ->
+        matches = Enum.sort_by(matches, & &1[:arity], :asc)
+        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
+
+  defp format_details_item(%{kind: :variable, name: name}), do: code(name)
+
+  defp format_details_item(%{kind: :map_field, name: name}), do: code(name)
+
+  defp 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
+    join_with_divider([
+      code(name),
+      """
+      **Default**
+
+      ```
+      #{inspect(default, pretty: true, width: @line_length)}
+      ```\
+      """
+    ])
+  end
+
+  defp 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(%{
+         kind: :function,
+         module: module,
+         name: name,
+         arity: arity,
+         documentation: documentation,
+         signatures: signatures,
+         specs: specs,
+         meta: meta
+       }) do
+    join_with_divider([
+      format_signatures(signatures, module, name, arity) |> code(),
+      join_with_middle_dot([
+        format_docs_link(module, {:function, name, arity}),
+        format_meta(:since, meta)
+      ]),
+      format_meta(:deprecated, meta),
+      format_specs(specs, name, @extended_line_length) |> code(),
+      Intellisense.Elixir.Docs.format_documentation(documentation, :all)
+    ])
+  end
+
+  defp format_details_item(%{
+         kind: :type,
+         module: module,
+         name: name,
+         arity: arity,
+         documentation: documentation,
+         type_spec: type_spec
+       }) do
+    join_with_divider([
+      format_type_signature(type_spec, module, name, arity) |> code(),
+      format_docs_link(module, {:type, name, arity}),
+      format_type_spec(type_spec, @extended_line_length) |> code(),
+      Intellisense.Elixir.Docs.format_documentation(documentation, :all)
+    ])
+  end
+
+  defp 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
+    get_definition_location(module, context, {:module, module})
+  end
+
+  defp 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
+    get_definition_location(module, context, {:type, name, arity})
+  end
+
+  defp get_definition_location(_idenfitier, _context), do: nil
+
+  defp 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]
+        %{file: to_string(file), line: line}
+      else
+        _otherwise -> nil
+      end
+    end
+  end
+
+  defp handle_signature(hint, context, node) do
+    case Intellisense.Elixir.SignatureMatcher.get_matching_signatures(hint, context, node) do
+      {:ok, [], _active_argument} ->
+        nil
+
+      {:ok, signature_infos, active_argument} ->
+        %{
+          active_argument: active_argument,
+          items:
+            signature_infos
+            |> Enum.map(&format_signature_item/1)
+            |> Enum.uniq()
+        }
+
+      :error ->
+        nil
+    end
+  end
+
+  defp format_signature_item({_name, signature, _documentation, _specs}),
+    do: %{
+      signature: signature,
+      arguments: arguments_from_signature(signature)
+    }
+
+  defp arguments_from_signature(signature) do
+    signature
+    |> Code.string_to_quoted!()
+    |> elem(2)
+    |> Enum.map(&Macro.to_string/1)
+  end
+
+  # Formatting helpers
+
+  defp join_with_divider(strings), do: join_with(strings, "\n\n---\n\n")
+
+  defp join_with_newlines(strings), do: join_with(strings, "\n\n")
+
+  defp join_with_middle_dot(strings), do: join_with(strings, " · ")
+
+  defp 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
+
+  defp code(code) do
+    """
+    ```
+    #{code}
+    ```\
+    """
+  end
+
+  defp format_docs_link(module, function_or_type \\ nil) do
+    app = Application.get_application(module)
+    module_name = module_name(module)
+
+    is_otp? =
+      case :code.which(module) do
+        :preloaded -> true
+        [_ | _] = path -> List.starts_with?(path, :code.lib_dir())
+        _ -> false
+      end
+
+    cond do
+      is_otp? ->
+        hash =
+          case function_or_type do
+            {:function, function, arity} -> "##{function}-#{arity}"
+            {:type, type, _arity} -> "#type-#{type}"
+            nil -> ""
+          end
+
+        url = "https://www.erlang.org/doc/man/#{module_name}.html#{hash}"
+        "[View on Erlang Docs](#{url})"
+
+      vsn = app && Application.spec(app, :vsn) ->
+        hash =
+          case function_or_type do
+            {:function, function, arity} -> "##{function}/#{arity}"
+            {:type, type, arity} -> "#t:#{type}/#{arity}"
+            nil -> ""
+          end
+
+        url = "https://hexdocs.pm/#{app}/#{vsn}/#{module_name}.html#{hash}"
+        "[View on Hexdocs](#{url})"
+
+      true ->
+        nil
+    end
+  end
+
+  defp module_name(module) do
+    case Atom.to_string(module) do
+      "Elixir." <> name -> name
+      name -> name
+    end
+  end
+
+  defp format_signatures([], module, name, arity) do
+    signature_fallback(module, name, arity)
+  end
+
+  defp format_signatures(signatures, module, _name, _arity) do
+    signatures_string = Enum.join(signatures, "\n")
+
+    # Don't add module prefix to operator signatures
+    if :binary.match(signatures_string, ["(", "/"]) != :nomatch do
+      inspect(module) <> "." <> signatures_string
+    else
+      signatures_string
+    end
+  end
+
+  defp format_type_signature(nil, module, name, arity) do
+    signature_fallback(module, name, arity)
+  end
+
+  defp format_type_signature({_type_kind, type}, module, _name, _arity) do
+    {:"::", _env, [lhs, _rhs]} = Code.Typespec.type_to_quoted(type)
+    inspect(module) <> "." <> Macro.to_string(lhs)
+  end
+
+  defp signature_fallback(module, name, arity) do
+    args = Enum.map_join(1..arity//1, ", ", fn n -> "arg#{n}" end)
+    "#{inspect(module)}.#{name}(#{args})"
+  end
+
+  defp format_meta(:deprecated, %{deprecated: deprecated}) do
+    "**Deprecated**. " <> deprecated
+  end
+
+  defp format_meta(:since, %{since: since}) do
+    "Since " <> since
+  end
+
+  defp format_meta(_, _), do: nil
+
+  defp format_specs([], _name, _line_length), do: nil
+
+  defp format_specs(specs, name, line_length) do
+    spec_lines =
+      Enum.map(specs, fn spec ->
+        code = Code.Typespec.spec_to_quoted(name, spec) |> Macro.to_string()
+        ["@spec ", code]
+      end)
+
+    specs_code =
+      spec_lines
+      |> Enum.intersperse("\n")
+      |> IO.iodata_to_binary()
+
+    try do
+      Code.format_string!(specs_code, line_length: line_length)
+    rescue
+      _ -> specs_code
+    end
+  end
+
+  defp format_type_spec({type_kind, type}, line_length) when type_kind in [:type, :opaque] do
+    ast = {:"::", _env, [lhs, _rhs]} = Code.Typespec.type_to_quoted(type)
+
+    type_string =
+      case type_kind do
+        :type -> ast
+        :opaque -> lhs
+      end
+      |> Macro.to_string()
+
+    type_spec_code = "@#{type_kind} #{type_string}"
+
+    try do
+      Code.format_string!(type_spec_code, line_length: line_length)
+    rescue
+      _ -> type_spec_code
+    end
+  end
+
+  defp format_type_spec(_, _line_length), do: nil
+end
diff --git a/lib/livebook/intellisense/docs.ex b/lib/livebook/intellisense/elixir/docs.ex
similarity index 50%
rename from lib/livebook/intellisense/docs.ex
rename to lib/livebook/intellisense/elixir/docs.ex
index 01915a2c0..780609771 100644
--- a/lib/livebook/intellisense/docs.ex
+++ b/lib/livebook/intellisense/elixir/docs.ex
@@ -1,4 +1,4 @@
-defmodule Livebook.Intellisense.Docs do
+defmodule Livebook.Intellisense.Elixir.Docs do
   # This module is responsible for extracting and normalizing
   # information like documentation, signatures and specs.
   #
@@ -230,4 +230,245 @@ defmodule Livebook.Intellisense.Docs do
   defp keyfind(list, key) do
     List.keyfind(list, key, 0) || :error
   end
+
+  @doc """
+  Formats the given documentation content as Markdown.
+
+  The `variant` argument can be either `:all` to return the full content,
+  or `:short` to return only the first paragraph.
+  """
+  @spec format_documentation(documentation(), :all | :short) :: String.t()
+  def format_documentation(doc, variant)
+
+  def format_documentation(nil, _variant) do
+    "No documentation available"
+  end
+
+  def format_documentation(:hidden, _variant) do
+    "This is a private API"
+  end
+
+  def format_documentation({"text/markdown", markdown}, :short) do
+    # Extract just the first paragraph
+    markdown
+    |> String.split("\n\n")
+    |> hd()
+    |> String.trim()
+  end
+
+  def format_documentation({"application/erlang+html", erlang_html}, :short) do
+    # Extract just the first paragraph
+    erlang_html
+    |> Enum.find(&match?({:p, _, _}, &1))
+    |> case do
+      nil -> nil
+      paragraph -> erlang_html_to_md([paragraph])
+    end
+  end
+
+  def format_documentation({"text/markdown", markdown}, :all) do
+    markdown
+  end
+
+  def format_documentation({"application/erlang+html", erlang_html}, :all) do
+    erlang_html_to_md(erlang_html)
+  end
+
+  def format_documentation({format, _content}, _variant) do
+    raise "unknown documentation format #{inspect(format)}"
+  end
+
+  # Erlang HTML AST
+  # See https://erlang.org/doc/apps/erl_docgen/doc_storage.html#erlang-documentation-format
+
+  defp erlang_html_to_md(ast) do
+    build_md([], ast)
+    |> IO.iodata_to_binary()
+    |> String.trim()
+  end
+
+  defp build_md(iodata, ast)
+
+  defp build_md(iodata, []), do: iodata
+
+  defp build_md(iodata, [string | ast]) when is_binary(string) do
+    string |> append_inline(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{tag, _, content} | ast]) when tag in [:em, :i] do
+    render_emphasis(content) |> append_inline(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{tag, _, content} | ast]) when tag in [:strong, :b] do
+    render_strong(content) |> append_inline(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{:code, _, content} | ast]) do
+    render_code_inline(content) |> append_inline(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{:a, attrs, content} | ast]) do
+    render_link(content, attrs) |> append_inline(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{:br, _, []} | ast]) do
+    render_line_break() |> append_inline(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{tag, _, content} | ast]) when tag in [:p, :div] do
+    render_paragraph(content) |> append_block(iodata) |> build_md(ast)
+  end
+
+  @headings ~w(h1 h2 h3 h4 h5 h6)a
+
+  defp build_md(iodata, [{tag, _, content} | ast]) when tag in @headings do
+    n = 1 + Enum.find_index(@headings, &(&1 == tag))
+    render_heading(n, content) |> append_block(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{:pre, _, [{:code, _, [content]}]} | ast]) do
+    render_code_block(content, "erlang") |> append_block(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{:div, [{:class, class} | _], content} | ast]) do
+    type = class |> to_string() |> String.upcase()
+
+    render_blockquote([{:p, [], [{:strong, [], [type]}]} | content])
+    |> append_block(iodata)
+    |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{:ul, [{:class, "types"} | _], content} | ast]) do
+    render_types_list(content) |> append_block(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{:ul, _, content} | ast]) do
+    render_unordered_list(content) |> append_block(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{:ol, _, content} | ast]) do
+    render_ordered_list(content) |> append_block(iodata) |> build_md(ast)
+  end
+
+  defp build_md(iodata, [{:dl, _, content} | ast]) do
+    render_description_list(content) |> append_block(iodata) |> build_md(ast)
+  end
+
+  defp append_inline(md, iodata), do: [iodata, md]
+  defp append_block(md, iodata), do: [iodata, "\n", md, "\n"]
+
+  # Renderers
+
+  defp render_emphasis(content) do
+    ["*", build_md([], content), "*"]
+  end
+
+  defp render_strong(content) do
+    ["**", build_md([], content), "**"]
+  end
+
+  defp render_code_inline(content) do
+    ["`", build_md([], content), "`"]
+  end
+
+  defp render_link(content, attrs) do
+    caption = build_md([], content)
+
+    if href = attrs[:href] do
+      ["[", caption, "](", href, ")"]
+    else
+      caption
+    end
+  end
+
+  defp render_line_break(), do: "\\\n"
+
+  defp render_paragraph(content), do: erlang_html_to_md(content)
+
+  defp render_heading(n, content) do
+    title = build_md([], content)
+    [String.duplicate("#", n), " ", title]
+  end
+
+  defp render_code_block(content, language) do
+    ["```", language, "\n", content, "\n```"]
+  end
+
+  defp render_blockquote(content) do
+    inner = erlang_html_to_md(content)
+
+    inner
+    |> String.split("\n")
+    |> Enum.map_intersperse("\n", &["> ", &1])
+  end
+
+  defp render_unordered_list(content) do
+    marker_fun = fn _index -> "* " end
+    render_list(content, marker_fun, "  ")
+  end
+
+  defp render_ordered_list(content) do
+    marker_fun = fn index -> "#{index + 1}. " end
+    render_list(content, marker_fun, "   ")
+  end
+
+  defp render_list(items, marker_fun, indent) do
+    spaced? = spaced_list_items?(items)
+    item_separator = if(spaced?, do: "\n\n", else: "\n")
+
+    items
+    |> Enum.map(fn {:li, _, content} -> erlang_html_to_md(content) end)
+    |> Enum.with_index()
+    |> Enum.map(fn {inner, index} ->
+      [first_line | lines] = String.split(inner, "\n")
+
+      first_line = marker_fun.(index) <> first_line
+
+      lines =
+        Enum.map(lines, fn
+          "" -> ""
+          line -> indent <> line
+        end)
+
+      Enum.intersperse([first_line | lines], "\n")
+    end)
+    |> Enum.intersperse(item_separator)
+  end
+
+  defp spaced_list_items?([{:li, _, [{:p, _, _content} | _]} | _items]), do: true
+  defp spaced_list_items?([_ | items]), do: spaced_list_items?(items)
+  defp spaced_list_items?([]), do: false
+
+  defp render_description_list(content) do
+    # Rewrite description list as an unordered list with pseudo heading
+    content
+    |> Enum.chunk_every(2)
+    |> Enum.map(fn [{:dt, _, dt}, {:dd, _, dd}] ->
+      {:li, [], [{:p, [], [{:strong, [], dt}]}, {:p, [], dd}]}
+    end)
+    |> render_unordered_list()
+  end
+
+  defp render_types_list(content) do
+    content
+    |> group_type_list_items([])
+    |> render_unordered_list()
+  end
+
+  defp group_type_list_items([], acc), do: Enum.reverse(acc)
+
+  defp group_type_list_items([{:li, [{:name, _type_name}], []} | items], acc) do
+    group_type_list_items(items, acc)
+  end
+
+  defp group_type_list_items([{:li, [{:class, "type"}], content} | items], acc) do
+    group_type_list_items(items, [{:li, [], [{:code, [], content}]} | acc])
+  end
+
+  defp group_type_list_items(
+         [{:li, [{:class, "description"}], content} | items],
+         [{:li, [], prev_content} | acc]
+       ) do
+    group_type_list_items(items, [{:li, [], prev_content ++ [{:p, [], content}]} | acc])
+  end
 end
diff --git a/lib/livebook/intellisense/identifier_matcher.ex b/lib/livebook/intellisense/elixir/identifier_matcher.ex
similarity index 97%
rename from lib/livebook/intellisense/identifier_matcher.ex
rename to lib/livebook/intellisense/elixir/identifier_matcher.ex
index 1589819ab..592d35ad3 100644
--- a/lib/livebook/intellisense/identifier_matcher.ex
+++ b/lib/livebook/intellisense/elixir/identifier_matcher.ex
@@ -1,4 +1,4 @@
-defmodule Livebook.Intellisense.IdentifierMatcher do
+defmodule Livebook.Intellisense.Elixir.IdentifierMatcher do
   # This module allows for extracting information about identifiers
   # based on code and runtime information (binding, environment).
   #
@@ -11,7 +11,7 @@ defmodule Livebook.Intellisense.IdentifierMatcher do
   # Server.
 
   alias Livebook.Intellisense
-  alias Livebook.Intellisense.Docs
+  alias Livebook.Intellisense.Elixir.Docs
 
   @typedoc """
   A single identifier together with relevant information.
@@ -525,7 +525,7 @@ defmodule Livebook.Intellisense.IdentifierMatcher do
           kind: :module,
           module: mod,
           display_name: name,
-          documentation: Intellisense.Docs.get_module_documentation(mod, ctx.node)
+          documentation: Intellisense.Elixir.Docs.get_module_documentation(mod, ctx.node)
         }
   end
 
@@ -549,7 +549,7 @@ defmodule Livebook.Intellisense.IdentifierMatcher do
           kind: :module,
           module: mod,
           display_name: name,
-          documentation: Intellisense.Docs.get_module_documentation(mod, ctx.node)
+          documentation: Intellisense.Elixir.Docs.get_module_documentation(mod, ctx.node)
         }
   end
 
@@ -603,7 +603,7 @@ defmodule Livebook.Intellisense.IdentifierMatcher do
           kind: :module,
           module: mod,
           display_name: name,
-          documentation: Intellisense.Docs.get_module_documentation(mod, ctx.node)
+          documentation: Intellisense.Elixir.Docs.get_module_documentation(mod, ctx.node)
         }
   end
 
@@ -682,7 +682,7 @@ defmodule Livebook.Intellisense.IdentifierMatcher do
         end)
 
       doc_items =
-        Intellisense.Docs.lookup_module_members(
+        Intellisense.Elixir.Docs.lookup_module_members(
           mod,
           Enum.map(matching_funs, &Tuple.delete_at(&1, 2)),
           ctx.node,
@@ -755,7 +755,9 @@ defmodule Livebook.Intellisense.IdentifierMatcher do
       end)
 
     doc_items =
-      Intellisense.Docs.lookup_module_members(mod, matching_types, ctx.node, kinds: [:type])
+      Intellisense.Elixir.Docs.lookup_module_members(mod, matching_types, ctx.node,
+        kinds: [:type]
+      )
 
     Enum.map(matching_types, fn {name, arity} ->
       doc_item =
diff --git a/lib/livebook/intellisense/signature_matcher.ex b/lib/livebook/intellisense/elixir/signature_matcher.ex
similarity index 97%
rename from lib/livebook/intellisense/signature_matcher.ex
rename to lib/livebook/intellisense/elixir/signature_matcher.ex
index 562898290..6f981b0cb 100644
--- a/lib/livebook/intellisense/signature_matcher.ex
+++ b/lib/livebook/intellisense/elixir/signature_matcher.ex
@@ -1,8 +1,8 @@
-defmodule Livebook.Intellisense.SignatureMatcher do
+defmodule Livebook.Intellisense.Elixir.SignatureMatcher do
   # This module allows for extracting information about function
   # signatures matching an incomplete call.
 
-  alias Livebook.Intellisense.Docs
+  alias Livebook.Intellisense.Elixir.Docs
 
   @type signature_info :: {name :: atom(), Docs.signature(), Docs.documentation(), Docs.spec()}
 
@@ -52,7 +52,7 @@ defmodule Livebook.Intellisense.SignatureMatcher do
 
   defp signature_infos_for_members(mod, funs, active_argument, node) do
     infos =
-      Livebook.Intellisense.Docs.lookup_module_members(mod, funs, node,
+      Livebook.Intellisense.Elixir.Docs.lookup_module_members(mod, funs, node,
         kinds: [:function, :macro]
       )
 
diff --git a/lib/livebook/intellisense/erlang.ex b/lib/livebook/intellisense/erlang.ex
new file mode 100644
index 000000000..849b0ff7e
--- /dev/null
+++ b/lib/livebook/intellisense/erlang.ex
@@ -0,0 +1,38 @@
+defmodule Livebook.Intellisense.Erlang do
+  alias Livebook.Intellisense
+
+  @behaviour Intellisense
+
+  @impl true
+  def handle_request({:format, _code}, _context, _node) do
+    # Not supported.
+    nil
+  end
+
+  def handle_request({:completion, hint}, context, _node) do
+    handle_completion(hint, context)
+  end
+
+  def handle_request({:details, line, column}, context, _node) do
+    handle_details(line, column, context)
+  end
+
+  def handle_request({:signature, hint}, context, _node) do
+    handle_signature(hint, context)
+  end
+
+  defp handle_completion(_hint, _context) do
+    # TODO: implement. See t:Livebook.Runtime.completion_response/0 for return type.
+    nil
+  end
+
+  defp handle_details(_line, _column, _context) do
+    # TODO: implement. See t:Livebook.Runtime.details_response/0 for return type.
+    nil
+  end
+
+  defp handle_signature(_hint, _context) do
+    # TODO: implement. See t:Livebook.Runtime.signature_response/0 for return type.
+    nil
+  end
+end
diff --git a/lib/livebook/notebook/cell/code.ex b/lib/livebook/notebook/cell/code.ex
index c1c392637..5f7bd6148 100644
--- a/lib/livebook/notebook/cell/code.ex
+++ b/lib/livebook/notebook/cell/code.ex
@@ -41,7 +41,7 @@ defmodule Livebook.Notebook.Cell.Code do
   end
 
   @doc """
-  Return the list of supported langauges for code cells.
+  Return the list of supported languages for code cells.
   """
   @spec languages() :: list(%{name: String.t(), language: atom()})
   def languages() do
diff --git a/lib/livebook/runtime.ex b/lib/livebook/runtime.ex
index 7c55fbd9b..12e537012 100644
--- a/lib/livebook/runtime.ex
+++ b/lib/livebook/runtime.ex
@@ -969,11 +969,12 @@ defprotocol Livebook.Runtime do
   @spec handle_intellisense(
           t(),
           pid(),
+          language(),
           intellisense_request(),
           parent_locators(),
           {atom(), atom()} | nil
         ) :: reference()
-  def handle_intellisense(runtime, send_to, request, parent_locators, node)
+  def handle_intellisense(runtime, send_to, language, request, parent_locators, node)
 
   @doc """
   Reads file at the given absolute path within the runtime file system.
diff --git a/lib/livebook/runtime/attached.ex b/lib/livebook/runtime/attached.ex
index e834a449f..5a50e25a4 100644
--- a/lib/livebook/runtime/attached.ex
+++ b/lib/livebook/runtime/attached.ex
@@ -159,8 +159,15 @@ defimpl Livebook.Runtime, for: Livebook.Runtime.Attached do
     RuntimeServer.drop_container(runtime.server_pid, container_ref)
   end
 
-  def handle_intellisense(runtime, send_to, request, parent_locators, node) do
-    RuntimeServer.handle_intellisense(runtime.server_pid, send_to, request, parent_locators, node)
+  def handle_intellisense(runtime, send_to, language, request, parent_locators, node) do
+    RuntimeServer.handle_intellisense(
+      runtime.server_pid,
+      send_to,
+      language,
+      request,
+      parent_locators,
+      node
+    )
   end
 
   def read_file(runtime, path) do
diff --git a/lib/livebook/runtime/embedded.ex b/lib/livebook/runtime/embedded.ex
index 872824a85..1c3052dc3 100644
--- a/lib/livebook/runtime/embedded.ex
+++ b/lib/livebook/runtime/embedded.ex
@@ -90,8 +90,15 @@ defimpl Livebook.Runtime, for: Livebook.Runtime.Embedded do
     RuntimeServer.drop_container(runtime.server_pid, container_ref)
   end
 
-  def handle_intellisense(runtime, send_to, request, parent_locators, node) do
-    RuntimeServer.handle_intellisense(runtime.server_pid, send_to, request, parent_locators, node)
+  def handle_intellisense(runtime, send_to, language, request, parent_locators, node) do
+    RuntimeServer.handle_intellisense(
+      runtime.server_pid,
+      send_to,
+      language,
+      request,
+      parent_locators,
+      node
+    )
   end
 
   def read_file(runtime, path) do
diff --git a/lib/livebook/runtime/erl_dist.ex b/lib/livebook/runtime/erl_dist.ex
index 0c59bd4bc..3e08bdfc5 100644
--- a/lib/livebook/runtime/erl_dist.ex
+++ b/lib/livebook/runtime/erl_dist.ex
@@ -31,9 +31,11 @@ defmodule Livebook.Runtime.ErlDist do
       Livebook.Runtime.Evaluator.Formatter,
       Livebook.Runtime.Evaluator.Doctests,
       Livebook.Intellisense,
-      Livebook.Intellisense.Docs,
-      Livebook.Intellisense.IdentifierMatcher,
-      Livebook.Intellisense.SignatureMatcher,
+      Livebook.Intellisense.Elixir,
+      Livebook.Intellisense.Elixir.Docs,
+      Livebook.Intellisense.Elixir.IdentifierMatcher,
+      Livebook.Intellisense.Elixir.SignatureMatcher,
+      Livebook.Intellisense.Erlang,
       Livebook.Runtime.ErlDist,
       Livebook.Runtime.ErlDist.NodeManager,
       Livebook.Runtime.ErlDist.RuntimeServer,
diff --git a/lib/livebook/runtime/erl_dist/runtime_server.ex b/lib/livebook/runtime/erl_dist/runtime_server.ex
index 14173bb3d..28bca9a28 100644
--- a/lib/livebook/runtime/erl_dist/runtime_server.ex
+++ b/lib/livebook/runtime/erl_dist/runtime_server.ex
@@ -125,13 +125,19 @@ defmodule Livebook.Runtime.ErlDist.RuntimeServer do
   @spec handle_intellisense(
           pid(),
           pid(),
+          Runtime.language(),
           Runtime.intellisense_request(),
           Runtime.Runtime.parent_locators(),
           {atom(), atom()} | nil
         ) :: reference()
-  def handle_intellisense(pid, send_to, request, parent_locators, node) do
+  def handle_intellisense(pid, send_to, language, request, parent_locators, node) do
     ref = make_ref()
-    GenServer.cast(pid, {:handle_intellisense, send_to, ref, request, parent_locators, node})
+
+    GenServer.cast(
+      pid,
+      {:handle_intellisense, send_to, ref, language, request, parent_locators, node}
+    )
+
     ref
   end
 
@@ -546,7 +552,7 @@ defmodule Livebook.Runtime.ErlDist.RuntimeServer do
   end
 
   def handle_cast(
-        {:handle_intellisense, send_to, ref, request, parent_locators, node},
+        {:handle_intellisense, send_to, ref, language, request, parent_locators, node},
         state
       ) do
     {container_ref, parent_evaluation_refs} =
@@ -577,7 +583,10 @@ defmodule Livebook.Runtime.ErlDist.RuntimeServer do
 
     Task.Supervisor.start_child(state.task_supervisor, fn ->
       node = intellisense_node(node)
-      response = Livebook.Intellisense.handle_request(request, intellisense_context, node)
+
+      response =
+        Livebook.Intellisense.handle_request(language, request, intellisense_context, node)
+
       send(send_to, {:runtime_intellisense_response, ref, request, response})
     end)
 
diff --git a/lib/livebook/runtime/fly.ex b/lib/livebook/runtime/fly.ex
index 7d16dd3b0..80d1b7dce 100644
--- a/lib/livebook/runtime/fly.ex
+++ b/lib/livebook/runtime/fly.ex
@@ -426,8 +426,15 @@ defimpl Livebook.Runtime, for: Livebook.Runtime.Fly do
     RuntimeServer.drop_container(runtime.server_pid, container_ref)
   end
 
-  def handle_intellisense(runtime, send_to, request, parent_locators, node) do
-    RuntimeServer.handle_intellisense(runtime.server_pid, send_to, request, parent_locators, node)
+  def handle_intellisense(runtime, send_to, language, request, parent_locators, node) do
+    RuntimeServer.handle_intellisense(
+      runtime.server_pid,
+      send_to,
+      language,
+      request,
+      parent_locators,
+      node
+    )
   end
 
   def read_file(runtime, path) do
diff --git a/lib/livebook/runtime/k8s.ex b/lib/livebook/runtime/k8s.ex
index f7054a9eb..a09495acc 100644
--- a/lib/livebook/runtime/k8s.ex
+++ b/lib/livebook/runtime/k8s.ex
@@ -365,8 +365,15 @@ defimpl Livebook.Runtime, for: Livebook.Runtime.K8s do
     RuntimeServer.drop_container(runtime.server_pid, container_ref)
   end
 
-  def handle_intellisense(runtime, send_to, request, parent_locators, node) do
-    RuntimeServer.handle_intellisense(runtime.server_pid, send_to, request, parent_locators, node)
+  def handle_intellisense(runtime, send_to, language, request, parent_locators, node) do
+    RuntimeServer.handle_intellisense(
+      runtime.server_pid,
+      send_to,
+      language,
+      request,
+      parent_locators,
+      node
+    )
   end
 
   def read_file(runtime, path) do
diff --git a/lib/livebook/runtime/standalone.ex b/lib/livebook/runtime/standalone.ex
index 424e64bf7..3333a1d0b 100644
--- a/lib/livebook/runtime/standalone.ex
+++ b/lib/livebook/runtime/standalone.ex
@@ -283,8 +283,15 @@ defimpl Livebook.Runtime, for: Livebook.Runtime.Standalone do
     RuntimeServer.drop_container(runtime.server_pid, container_ref)
   end
 
-  def handle_intellisense(runtime, send_to, request, parent_locators, node) do
-    RuntimeServer.handle_intellisense(runtime.server_pid, send_to, request, parent_locators, node)
+  def handle_intellisense(runtime, send_to, language, request, parent_locators, node) do
+    RuntimeServer.handle_intellisense(
+      runtime.server_pid,
+      send_to,
+      language,
+      request,
+      parent_locators,
+      node
+    )
   end
 
   def read_file(runtime, path) do
diff --git a/lib/livebook/session.ex b/lib/livebook/session.ex
index 9318ea4d8..e6320e19c 100644
--- a/lib/livebook/session.ex
+++ b/lib/livebook/session.ex
@@ -452,7 +452,7 @@ defmodule Livebook.Session do
   end
 
   @doc """
-  Requests the given langauge to be enabled.
+  Requests the given language to be enabled.
 
   This inserts extra cells and adds dependencies if applicable.
   """
@@ -462,7 +462,7 @@ defmodule Livebook.Session do
   end
 
   @doc """
-  Requests the given langauge to be disabled.
+  Requests the given language to be disabled.
   """
   @spec disable_language(pid(), atom()) :: :ok
   def disable_language(pid, language) do
diff --git a/lib/livebook_web/live/hub/teams/deployment_group_form_component.ex b/lib/livebook_web/live/hub/teams/deployment_group_form_component.ex
index 02f625e73..4bc2cb64f 100644
--- a/lib/livebook_web/live/hub/teams/deployment_group_form_component.ex
+++ b/lib/livebook_web/live/hub/teams/deployment_group_form_component.ex
@@ -131,7 +131,10 @@ defmodule LivebookWeb.Hub.Teams.DeploymentGroupFormComponent do
     ~H"""
     <label class={[
       "relative flex rounded-lg border p-4 w-1/2",
-      if(to_string(@field.value) == to_string(@value), do: "border-blue-500", else: "border-gray-200"),
+      if(to_string(@field.value) == to_string(@value),
+        do: "border-blue-500",
+        else: "border-gray-200"
+      ),
       if(@disabled, do: "opacity-70", else: "cursor-pointer")
     ]}>
       <input
diff --git a/lib/livebook_web/live/session_live.ex b/lib/livebook_web/live/session_live.ex
index 33b5b9315..01821d0c5 100644
--- a/lib/livebook_web/live/session_live.ex
+++ b/lib/livebook_web/live/session_live.ex
@@ -659,6 +659,7 @@ defmodule LivebookWeb.SessionLive do
           Livebook.Runtime.handle_intellisense(
             data.runtime,
             self(),
+            cell.language,
             request,
             parent_locators,
             node
diff --git a/lib/livebook_web/live/session_live/cell_component.ex b/lib/livebook_web/live/session_live/cell_component.ex
index a3f11b645..9c724eee4 100644
--- a/lib/livebook_web/live/session_live/cell_component.ex
+++ b/lib/livebook_web/live/session_live/cell_component.ex
@@ -207,11 +207,11 @@ defmodule LivebookWeb.SessionLive.CellComponent do
             tag="primary"
             empty={@cell_view.empty}
             language={@cell_view.language}
-            intellisense={@cell_view.language == :elixir}
+            intellisense={@cell_view.language in [:elixir, :erlang]}
           />
         </div>
         <div class="absolute bottom-2 right-2" data-el-cell-indicators>
-          <.cell_indicators id={@cell_view.id} cell_view={@cell_view} langauge_toggle />
+          <.cell_indicators id={@cell_view.id} cell_view={@cell_view} language_toggle />
         </div>
       </div>
       <div :if={@cell_view.language not in @enabled_languages} class="mt-2">
@@ -772,7 +772,7 @@ defmodule LivebookWeb.SessionLive.CellComponent do
 
   attr :id, :string, required: true
   attr :cell_view, :map, required: true
-  attr :langauge_toggle, :boolean, default: false
+  attr :language_toggle, :boolean, default: false
 
   defp cell_indicators(assigns) do
     ~H"""
@@ -780,7 +780,7 @@ defmodule LivebookWeb.SessionLive.CellComponent do
       <.cell_indicator :if={has_status?(@cell_view)}>
         <.cell_status id={@id} cell_view={@cell_view} />
       </.cell_indicator>
-      <%= if @langauge_toggle do %>
+      <%= if @language_toggle do %>
         <.menu id={"cell-#{@id}-language-menu"} position="bottom-right">
           <:toggle>
             <.cell_indicator class="cursor-pointer">
diff --git a/test/livebook/intellisense/elixir_test.exs b/test/livebook/intellisense/elixir_test.exs
new file mode 100644
index 000000000..d34c796b4
--- /dev/null
+++ b/test/livebook/intellisense/elixir_test.exs
@@ -0,0 +1,2504 @@
+defmodule Livebook.Intellisense.ElixirTest do
+  use ExUnit.Case, async: true
+
+  import Livebook.TestHelpers
+
+  alias Livebook.Intellisense
+
+  setup do
+    Intellisense.clear_cache(node())
+    :ok
+  end
+
+  describe "format" do
+    test "formats valid code" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               code: "1 + 1",
+               code_markers: []
+             } = Intellisense.Elixir.handle_request({:format, "1+1"}, context, node())
+    end
+
+    test "returns a syntax error when invalid code is given" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               code: nil,
+               code_markers: [
+                 %{
+                   line: 1,
+                   description: "syntax error: expression is incomplete",
+                   severity: :error
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:format, "1+"}, context, node())
+    end
+  end
+
+  describe "completion" do
+    test "completion when no hint given" do
+      context = intellisense_context_from_eval(do: nil)
+
+      length_item = %{
+        label: "length/1",
+        kind: :function,
+        documentation: """
+        Returns the length of `list`.
+
+        ```
+        Kernel.length(list)
+        ```\
+        """,
+        insert_text: "length(${})"
+      }
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, ""}, context, node())
+
+      assert length_item in items
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "to_string("}, context, node())
+
+      assert length_item in items
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "Enum.map(list, "},
+                 context,
+                 node()
+               )
+
+      assert length_item in items
+    end
+
+    @tag :erl_docs
+    test "Erlang module completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: ":zlib",
+                   kind: :module,
+                   documentation: """
+                   zlib compression interface.
+
+                   (module)\
+                   """,
+                   insert_text: "zlib"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, ":zl"}, context, node())
+    end
+
+    test "Erlang module no completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, ":unknown"}, context, node())
+    end
+
+    test "Erlang module multiple values completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: ":orddict",
+                   kind: :module,
+                   documentation: _orddict_doc,
+                   insert_text: "orddict"
+                 },
+                 %{
+                   label: ":ordsets",
+                   kind: :module,
+                   documentation: _ordsets_doc,
+                   insert_text: "ordsets"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, ":ord"}, context, node())
+    end
+
+    @tag :erl_docs
+    test "Erlang root completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      lists_item = %{
+        label: ":lists",
+        kind: :module,
+        documentation: """
+        List processing functions.
+
+        (module)\
+        """,
+        insert_text: "lists"
+      }
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, ":"}, context, node())
+
+      assert lists_item in items
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "  :"}, context, node())
+
+      assert lists_item in items
+    end
+
+    @tag :erl_docs
+    test "Erlang completion doesn't include quoted atoms" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, ~s{:Elixir}}, context, node())
+    end
+
+    @tag :erl_docs
+    test "Erlang module completion with 'in' operator in spec" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "open_port/2",
+                   kind: :function,
+                   documentation: _open_port_doc,
+                   insert_text: "open_port(${})"
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, ":erlang.open_por"},
+                 context,
+                 node()
+               )
+    end
+
+    @tag :erl_docs
+    test "Erlang type completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, ":maps.iterator"},
+                 context,
+                 node()
+               )
+
+      assert %{
+               label: "iterator/0",
+               kind: :type,
+               documentation: """
+               No documentation available
+
+               ```
+               @type iterator() :: iterator(term(), term())
+               ```\
+               """,
+               insert_text: "iterator()"
+             } in items
+
+      assert %{
+               label: "iterator/2",
+               kind: :type,
+               documentation: """
+               An iterator representing the associations in a map with keys of type `Key` and
+               values of type `Value`.
+
+               ```
+               @opaque iterator(key, value)
+               ```\
+               """,
+               insert_text: "iterator(${})"
+             } in items
+    end
+
+    test "Elixir proxy" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "Eli"}, context, node())
+
+      assert %{
+               label: "Elixir",
+               kind: :module,
+               documentation: """
+               No documentation available
+
+               (module)\
+               """,
+               insert_text: "Elixir"
+             } in items
+    end
+
+    test "Elixir module completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "Enum",
+                   kind: :module,
+                   documentation: """
+                   Functions for working with collections (known as enumerables).
+
+                   (module)\
+                   """,
+                   insert_text: "Enum"
+                 },
+                 %{
+                   label: "Enumerable",
+                   kind: :interface,
+                   documentation: """
+                   Enumerable protocol used by `Enum` and `Stream` modules.
+
+                   (protocol)\
+                   """,
+                   insert_text: "Enumerable"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "En"}, context, node())
+
+      assert %{
+               items: [
+                 %{
+                   label: "Enumerable",
+                   kind: :interface,
+                   documentation: """
+                   Enumerable protocol used by `Enum` and `Stream` modules.
+
+                   (protocol)\
+                   """,
+                   insert_text: "Enumerable"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "Enumera"}, context, node())
+
+      assert %{
+               items: [
+                 %{
+                   label: "RuntimeError",
+                   kind: :struct,
+                   documentation: """
+                   An exception for a generic runtime error.
+
+                   (exception)\
+                   """,
+                   insert_text: "RuntimeError"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "RuntimeE"}, context, node())
+    end
+
+    test "Elixir struct completion lists nested options" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "%Fi"}, context, node())
+
+      assert %{
+               label: "File.Stat",
+               kind: :struct,
+               documentation: """
+               A struct that holds file information.
+
+               (struct)\
+               """,
+               insert_text: "File.Stat"
+             } in items
+    end
+
+    test "Elixir type completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "from/0",
+                   kind: :type,
+                   documentation: """
+                   Tuple describing the client of a call request.
+
+                   ```
+                   @type from() :: {pid(), tag :: term()}
+                   ```\
+                   """,
+                   insert_text: "from()"
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request({:completion, "GenServer.fr"}, context, node())
+
+      assert %{
+               items: [
+                 %{
+                   label: "internal/1",
+                   kind: :type,
+                   documentation: """
+                   No documentation available
+
+                   ```
+                   @opaque internal(value)
+                   ```\
+                   """,
+                   insert_text: "internal(${})"
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request({:completion, "MapSet.intern"}, context, node())
+    end
+
+    test "Elixir module completion with self" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "Enumerable",
+                   kind: :interface,
+                   documentation: """
+                   Enumerable protocol used by `Enum` and `Stream` modules.
+
+                   (protocol)\
+                   """,
+                   insert_text: "Enumerable"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "Enumerable"}, context, node())
+    end
+
+    test "Elixir completion on modules from load path" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "R"}, context, node())
+
+      assert %{
+               label: "Req",
+               kind: :module,
+               documentation: """
+               The high-level API.
+
+               (module)\
+               """,
+               insert_text: "Req"
+             } in items
+    end
+
+    test "Elixir no completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, "."}, context, node())
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, "Xyz"}, context, node())
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, "x.Foo"}, context, node())
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, "x.Foo.get_by"}, context, node())
+    end
+
+    test "Elixir private module no completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "Livebook.TestModules.Hidd"},
+                 context,
+                 node()
+               )
+    end
+
+    test "Elixir private module members completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "visible/0",
+                   kind: :function,
+                   documentation: """
+                   No documentation available
+
+                   ```
+                   Livebook.TestModules.Hidden.visible()
+                   ```\
+                   """,
+                   insert_text: "visible()"
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "Livebook.TestModules.Hidden."},
+                 context,
+                 node()
+               )
+    end
+
+    test "Elixir root submodule completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "Access",
+                   kind: :interface,
+                   documentation: """
+                   Key-based access to data structures.
+
+                   (behaviour)\
+                   """,
+                   insert_text: "Access"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "Elixir.Acce"}, context, node())
+    end
+
+    test "Elixir submodule completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "ANSI",
+                   kind: :module,
+                   documentation: """
+                   Functionality to render ANSI escape sequences.
+
+                   (module)\
+                   """,
+                   insert_text: "ANSI"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "IO.AN"}, context, node())
+    end
+
+    test "Elixir submodule no completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, "IEx.Xyz"}, context, node())
+    end
+
+    test "Elixir function completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "version/0",
+                   kind: :function,
+                   documentation: """
+                   Elixir version information.
+
+                   ```
+                   System.version()
+                   ```\
+                   """,
+                   insert_text: "version()"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "System.ve"}, context, node())
+    end
+
+    test "Elixir sigil completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      regex_item = %{
+        label: "~r/2",
+        kind: :function,
+        documentation: """
+        Handles the sigil `~r` for regular expressions.
+
+        ```
+        Kernel.sigil_r(term, modifiers)
+        ```\
+        """,
+        insert_text: "~r"
+      }
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "~"}, context, node())
+
+      assert regex_item in items
+
+      assert %{items: [^regex_item]} =
+               Intellisense.Elixir.handle_request({:completion, "~r"}, context, node())
+    end
+
+    @tag :erl_docs
+    test "Erlang function completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, ":zlib.gz"}, context, node())
+
+      assert %{
+               label: "gzip/1",
+               kind: :function,
+               documentation: """
+               Compresses data with gz headers and checksum.
+
+               ```
+               :zlib.gzip(Data)
+               ```\
+               """,
+               insert_text: "gzip(${})"
+             } in items
+    end
+
+    test "function completion with arity" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "Enum.concat/"}, context, node())
+
+      assert %{
+               label: "concat/1",
+               kind: :function,
+               documentation: """
+               Given an enumerable of enumerables, concatenates the `enumerables` into
+               a single list.
+
+               ```
+               Enum.concat(enumerables)
+               ```\
+               """,
+               insert_text: "concat(${})"
+             } in items
+
+      assert %{
+               items: [
+                 %{label: "count/1"},
+                 %{label: "count/2"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "Enum.count/"}, context, node())
+    end
+
+    test "function completion same name with different arities" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "concat/1",
+                   kind: :function,
+                   documentation: """
+                   Given an enumerable of enumerables, concatenates the `enumerables` into
+                   a single list.
+
+                   ```
+                   Enum.concat(enumerables)
+                   ```\
+                   """,
+                   insert_text: "concat(${})"
+                 },
+                 %{
+                   label: "concat/2",
+                   kind: :function,
+                   documentation: """
+                   Concatenates the enumerable on the `right` with the enumerable on the
+                   `left`.
+
+                   ```
+                   Enum.concat(left, right)
+                   ```\
+                   """,
+                   insert_text: "concat(${})"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "Enum.concat"}, context, node())
+    end
+
+    test "function completion when has default args then documentation all arities have docs" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "utc_today/0",
+                   kind: :function,
+                   documentation: """
+                   Returns the current date in UTC.
+
+                   ```
+                   Date.utc_today(calendar \\\\ Calendar.ISO)
+                   ```\
+                   """,
+                   insert_text: "utc_today()"
+                 },
+                 %{
+                   label: "utc_today/1",
+                   kind: :function,
+                   documentation: """
+                   Returns the current date in UTC.
+
+                   ```
+                   Date.utc_today(calendar \\\\ Calendar.ISO)
+                   ```\
+                   """,
+                   insert_text: "utc_today(${})"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "Date.utc"}, context, node())
+    end
+
+    test "function completion using a variable bound to a module" do
+      context =
+        intellisense_context_from_eval do
+          mod = System
+        end
+
+      assert %{
+               items: [
+                 %{
+                   label: "version/0",
+                   kind: :function,
+                   documentation: """
+                   Elixir version information.
+
+                   ```
+                   System.version()
+                   ```\
+                   """,
+                   insert_text: "version()"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "mod.ve"}, context, node())
+    end
+
+    test "operator completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "++/2",
+                   kind: :function,
+                   documentation: """
+                   List concatenation operator. Concatenates a proper list and a term, returning a list.
+
+                   ```
+                   left ++ right
+                   ```\
+                   """,
+                   insert_text: "++"
+                 },
+                 %{
+                   label: "+/1",
+                   kind: :function,
+                   documentation: """
+                   Arithmetic positive unary operator.
+
+                   ```
+                   +value
+                   ```\
+                   """,
+                   insert_text: "+"
+                 },
+                 %{
+                   label: "+/2",
+                   kind: :function,
+                   documentation: """
+                   Arithmetic addition operator.
+
+                   ```
+                   left + right
+                   ```\
+                   """,
+                   insert_text: "+"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "+"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "+/1"},
+                 %{label: "+/2"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "+/"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "++/2"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "++/"}, context, node())
+    end
+
+    test "map atom key completion" do
+      context =
+        intellisense_context_from_eval do
+          map = %{
+            foo: 1,
+            bar_1: ~r/pattern/,
+            bar_2: true
+          }
+        end
+
+      assert %{
+               items: [
+                 %{
+                   label: "bar_1",
+                   kind: :field,
+                   documentation: "(field)",
+                   insert_text: "bar_1"
+                 },
+                 %{
+                   label: "bar_2",
+                   kind: :field,
+                   documentation: "(field)",
+                   insert_text: "bar_2"
+                 },
+                 %{
+                   label: "foo",
+                   kind: :field,
+                   documentation: "(field)",
+                   insert_text: "foo"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "map."}, context, node())
+
+      assert %{
+               items: [
+                 %{
+                   label: "foo",
+                   kind: :field,
+                   documentation: "(field)",
+                   insert_text: "foo"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "map.f"}, context, node())
+    end
+
+    test "nested map atom key completion" do
+      context =
+        intellisense_context_from_eval do
+          map = %{
+            nested: %{
+              deeply: %{
+                foo: 1,
+                bar_1: 23,
+                bar_2: 14,
+                mod: System
+              }
+            }
+          }
+        end
+
+      assert %{
+               items: [
+                 %{
+                   label: "nested",
+                   kind: :field,
+                   documentation: "(field)",
+                   insert_text: "nested"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "map.nest"}, context, node())
+
+      assert %{
+               items: [
+                 %{
+                   label: "foo",
+                   kind: :field,
+                   documentation: "(field)",
+                   insert_text: "foo"
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "map.nested.deeply.f"},
+                 context,
+                 node()
+               )
+
+      assert %{
+               items: [
+                 %{
+                   label: "version/0",
+                   kind: :function,
+                   documentation: """
+                   Elixir version information.
+
+                   ```
+                   System.version()
+                   ```\
+                   """,
+                   insert_text: "version()"
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "map.nested.deeply.mod.ve"},
+                 context,
+                 node()
+               )
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "map.non.existent"},
+                 context,
+                 node()
+               )
+    end
+
+    test "map string key completion is not supported" do
+      context =
+        intellisense_context_from_eval do
+          map = %{"foo" => 1}
+        end
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, "map.f"}, context, node())
+    end
+
+    test "autocompletion off a bound variable only works for modules and maps" do
+      context =
+        intellisense_context_from_eval do
+          num = 5
+          map = %{nested: %{num: 23}}
+        end
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, "num.print"}, context, node())
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "map.nested.num.f"},
+                 context,
+                 node()
+               )
+    end
+
+    test "autocompletion using access syntax does is not supported" do
+      context =
+        intellisense_context_from_eval do
+          map = %{nested: %{deeply: %{num: 23}}}
+        end
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "map[:nested][:deeply].n"},
+                 context,
+                 node()
+               )
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "map[:nested].deeply.n"},
+                 context,
+                 node()
+               )
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "map.nested.[:deeply].n"},
+                 context,
+                 node()
+               )
+    end
+
+    test "macro completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "is_nil/1",
+                   kind: :function,
+                   documentation: """
+                   Returns `true` if `term` is `nil`, `false` otherwise.
+
+                   ```
+                   Kernel.is_nil(term)
+                   ```\
+                   """,
+                   insert_text: "is_nil(${})"
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request({:completion, "Kernel.is_ni"}, context, node())
+    end
+
+    test "special forms completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "quote/2",
+                   kind: :function,
+                   documentation: """
+                   Gets the representation of any expression.
+
+                   ```
+                   Kernel.SpecialForms.quote(opts, block)
+                   ```\
+                   """,
+                   insert_text: "quote "
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "quot"}, context, node())
+    end
+
+    test "kernel import completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "put_in/2",
+                   kind: :function,
+                   documentation: """
+                   Puts a value in a nested structure via the given `path`.
+
+                   ```
+                   Kernel.put_in(path, value)
+                   ```\
+                   """,
+                   insert_text: "put_in(${})"
+                 },
+                 %{
+                   label: "put_in/3",
+                   kind: :function,
+                   documentation: """
+                   Puts a value in a nested structure.
+
+                   ```
+                   Kernel.put_in(data, keys, value)
+                   ```\
+                   """,
+                   insert_text: "put_in(${})"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "put_i"}, context, node())
+    end
+
+    test "variable name completion" do
+      context =
+        intellisense_context_from_eval do
+          number = 3
+          numbats = ["numbat", "numbat"]
+          nothing = nil
+        end
+
+      assert %{
+               items: [
+                 %{
+                   label: "numbats",
+                   kind: :variable,
+                   documentation: "(variable)",
+                   insert_text: "numbats"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "numba"}, context, node())
+
+      assert %{
+               items: [
+                 %{
+                   label: "numbats",
+                   kind: :variable,
+                   documentation: "(variable)",
+                   insert_text: "numbats"
+                 },
+                 %{
+                   label: "number",
+                   kind: :variable,
+                   documentation: "(variable)",
+                   insert_text: "number"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "num"}, context, node())
+
+      assert %{
+               items: [
+                 %{
+                   label: "nothing",
+                   kind: :variable,
+                   documentation: "(variable)",
+                   insert_text: "nothing"
+                 },
+                 %{label: "node/0"},
+                 %{label: "node/1"},
+                 %{label: "not/1"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "no"}, context, node())
+    end
+
+    test "completion of manually imported functions and macros" do
+      context =
+        intellisense_context_from_eval do
+          import Enum
+          import System, only: [version: 0]
+          import Protocol
+        end
+
+      assert %{
+               items: [
+                 %{label: "take/2"},
+                 %{label: "take_every/2"},
+                 %{label: "take_random/2"},
+                 %{label: "take_while/2"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "take"}, context, node())
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "v"}, context, node())
+
+      assert %{
+               label: "version/0",
+               kind: :function,
+               documentation: """
+               Elixir version information.
+
+               ```
+               System.version()
+               ```\
+               """,
+               insert_text: "version()"
+             } in items
+
+      assert %{
+               items: [
+                 %{label: "derive/2"},
+                 %{label: "derive/3"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "der"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "count/1"},
+                 %{label: "count/2"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "count/"}, context, node())
+    end
+
+    test "ignores quoted variables when performing variable completion" do
+      context =
+        intellisense_context_from_eval do
+          quote do
+            var!(my_var_1, Elixir) = 1
+          end
+
+          my_var_2 = 2
+        end
+
+      assert %{
+               items: [
+                 %{label: "my_var_2"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "my_var"}, context, node())
+    end
+
+    test "completion inside expression" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{label: "Enum"},
+                 %{label: "Enumerable"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "1 En"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "Enum"},
+                 %{label: "Enumerable"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "foo(En"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "Enum"},
+                 %{label: "Enumerable"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "Test En"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "Enum"},
+                 %{label: "Enumerable"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "foo(x,En"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "Enum"},
+                 %{label: "Enumerable"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "[En"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "Enum"},
+                 %{label: "Enumerable"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "{En"}, context, node())
+    end
+
+    test "ampersand completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{label: "Enum"},
+                 %{label: "Enumerable"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "&En"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "all?/1"},
+                 %{label: "all?/2"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "&Enum.al"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "all?/1"},
+                 %{label: "all?/2"}
+               ]
+             } =
+               Intellisense.Elixir.handle_request({:completion, "f = &Enum.al"}, context, node())
+    end
+
+    test "negation operator completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{label: "is_binary/1"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "!is_bin"}, context, node())
+    end
+
+    test "pin operator completion" do
+      context =
+        intellisense_context_from_eval do
+          my_variable = 2
+        end
+
+      assert %{
+               items: [
+                 %{label: "my_variable"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "^my_va"}, context, node())
+    end
+
+    @tag :tmp_dir
+    test "Elixir completion sublevel", %{tmp_dir: tmp_dir} do
+      context =
+        intellisense_context_from_eval tmp_dir do
+        end
+
+      compile_and_save_bytecode(tmp_dir, ~S'''
+      defmodule Livebook.Intellisense.ElixirTest.SublevelTest.LevelA.LevelB do
+      end
+      ''')
+
+      assert %{items: [%{label: "LevelA"}]} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "Livebook.Intellisense.ElixirTest.SublevelTest."},
+                 context,
+                 node()
+               )
+    end
+
+    test "complete aliases of Elixir modules" do
+      context =
+        intellisense_context_from_eval do
+          alias List, as: MyList
+        end
+
+      assert %{
+               items: [
+                 %{label: "MyList"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "MyL"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "to_integer/1"},
+                 %{label: "to_integer/2"}
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "MyList.to_integ"},
+                 context,
+                 node()
+               )
+    end
+
+    @tag :erl_docs
+    test "complete aliases of Erlang modules" do
+      context =
+        intellisense_context_from_eval do
+          alias :lists, as: EList
+        end
+
+      assert %{
+               items: [
+                 %{label: "EList"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "EL"}, context, node())
+
+      assert %{
+               items: [
+                 %{label: "map/2"},
+                 %{label: "mapfoldl/3"},
+                 %{label: "mapfoldr/3"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "EList.map"}, context, node())
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "EList."}, context, node())
+
+      assert %{
+               label: "max/1",
+               kind: :function,
+               documentation: """
+               Returns the first element of `List` that compares greater than or equal to all
+               other elements of `List`.
+
+               ```
+               :lists.max(List)
+               ```\
+               """,
+               insert_text: "max(${})"
+             } in items
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, "EList.Invalid"}, context, node())
+    end
+
+    test "completion for functions added when compiled module is reloaded" do
+      context = intellisense_context_from_eval(do: nil)
+
+      {:module, _, bytecode, _} =
+        defmodule Sample do
+          def foo(), do: 0
+        end
+
+      assert %{items: [%{label: "foo/0"}]} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "Livebook.Intellisense.ElixirTest.Sample.foo"},
+                 context,
+                 node()
+               )
+
+      Code.compiler_options(ignore_module_conflict: true)
+
+      defmodule Sample do
+        def foo(), do: 0
+        def foobar(), do: 0
+      end
+
+      assert %{
+               items: [
+                 %{label: "foo/0"},
+                 %{label: "foobar/0"}
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "Livebook.Intellisense.ElixirTest.Sample.foo"},
+                 context,
+                 node()
+               )
+    after
+      Code.compiler_options(ignore_module_conflict: false)
+      :code.purge(Sample)
+      :code.delete(Sample)
+    end
+
+    @tag :tmp_dir
+    test "completion for struct names", %{tmp_dir: tmp_dir} do
+      context =
+        intellisense_context_from_eval tmp_dir do
+        end
+
+      compile_and_save_bytecode(tmp_dir, ~S'''
+      defmodule Livebook.Intellisense.ElixirTest.MyStruct do
+        defstruct [:my_val]
+      end
+      ''')
+
+      assert %{
+               items: [
+                 %{label: "MyStruct"}
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "Livebook.Intellisense.ElixirTest.MyStr"},
+                 context,
+                 node()
+               )
+    end
+
+    @tag :tmp_dir
+    test "completion for struct keys", %{tmp_dir: tmp_dir} do
+      compile_and_save_bytecode(tmp_dir, ~S'''
+      defmodule Livebook.Intellisense.ElixirTest.MyStruct do
+        defstruct [:my_val]
+      end
+      ''')
+
+      context =
+        intellisense_context_from_eval tmp_dir do
+          struct = %Livebook.Intellisense.ElixirTest.MyStruct{}
+        end
+
+      assert %{
+               items: [
+                 %{label: "my_val"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "struct.my"}, context, node())
+    end
+
+    @tag :tmp_dir
+    test "completion for struct keys inside struct", %{tmp_dir: tmp_dir} do
+      context =
+        intellisense_context_from_eval tmp_dir do
+        end
+
+      compile_and_save_bytecode(tmp_dir, ~S'''
+      defmodule Livebook.Intellisense.ElixirTest.MyStruct do
+        defstruct [:my_val]
+      end
+      ''')
+
+      assert %{
+               items: [
+                 %{
+                   label: "my_val",
+                   kind: :field,
+                   documentation: """
+                   `%Livebook.Intellisense.ElixirTest.MyStruct{}` struct field.
+
+                   **Default**
+
+                   ```
+                   nil
+                   ```\
+                   """,
+                   insert_text: "my_val: "
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "%Livebook.Intellisense.ElixirTest.MyStruct{my"},
+                 context,
+                 node()
+               )
+    end
+
+    @tag :tmp_dir
+    test "completion for struct keys inside struct removes filled keys",
+         %{tmp_dir: tmp_dir} do
+      context =
+        intellisense_context_from_eval tmp_dir do
+        end
+
+      compile_and_save_bytecode(tmp_dir, ~S'''
+      defmodule Livebook.Intellisense.ElixirTest.MyStruct do
+        defstruct [:my_val]
+      end
+      ''')
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "%Livebook.Intellisense.ElixirTest.MyStruct{my_val: 123, "},
+                 context,
+                 node()
+               )
+    end
+
+    test "completion for struct keys inside struct ignores `__exception__`" do
+      context = intellisense_context_from_eval(do: nil)
+
+      completions =
+        Intellisense.Elixir.handle_request({:completion, "%ArgumentError{"}, context, node())
+
+      refute Enum.find(completions, &match?(%{label: "__exception__"}, &1))
+    end
+
+    @tag :tmp_dir
+    test "completion for struct keys in update syntax", %{tmp_dir: tmp_dir} do
+      context =
+        intellisense_context_from_eval tmp_dir do
+        end
+
+      compile_and_save_bytecode(tmp_dir, ~S'''
+      defmodule Livebook.Intellisense.ElixirTest.MyStruct do
+        defstruct [:my_val]
+      end
+      ''')
+
+      assert %{
+               items: [
+                 %{
+                   label: "my_val",
+                   kind: :field,
+                   documentation: _my_val_doc,
+                   insert_text: "my_val: "
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "%Livebook.Intellisense.ElixirTest.MyStruct{struct | "},
+                 context,
+                 node()
+               )
+
+      assert %{
+               items: [
+                 %{
+                   label: "my_val",
+                   kind: :field,
+                   documentation: _my_val_doc,
+                   insert_text: "my_val: "
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "%Livebook.Intellisense.ElixirTest.MyStruct{struct | my_v"},
+                 context,
+                 node()
+               )
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion,
+                  "%Livebook.Intellisense.ElixirTest.MyStruct{struct | my_val: 123, "},
+                 context,
+                 node()
+               )
+    end
+
+    test "completion for map keys in update syntax" do
+      context =
+        intellisense_context_from_eval do
+          map = %{foo: 1}
+        end
+
+      assert %{
+               items: [
+                 %{
+                   label: "foo",
+                   kind: :field,
+                   documentation: "(field)",
+                   insert_text: "foo: "
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "%{map | "}, context, node())
+
+      assert %{
+               items: [
+                 %{
+                   label: "foo",
+                   kind: :field,
+                   documentation: "(field)",
+                   insert_text: "foo: "
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "%{map | fo"}, context, node())
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "%{map | foo: 2, "},
+                 context,
+                 node()
+               )
+    end
+
+    test "ignore invalid Elixir module literals" do
+      context = intellisense_context_from_eval(do: nil)
+
+      defmodule(:"Elixir.Livebook.Intellisense.ElixirTest.Unicodé", do: nil)
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "Livebook.Intellisense.ElixirTest.Unicod"},
+                 context,
+                 node()
+               )
+    after
+      :code.purge(:"Elixir.Livebook.Intellisense.ElixirTest.Unicodé")
+      :code.delete(:"Elixir.Livebook.Intellisense.ElixirTest.Unicodé")
+    end
+
+    test "known Elixir module attributes completion" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "moduledoc",
+                   kind: :variable,
+                   documentation: """
+                   Provides documentation for the current module.
+
+                   (module attribute)\
+                   """,
+                   insert_text: "moduledoc"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "@modu"}, context, node())
+    end
+
+    test "handles calls on module attribute" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: []} =
+               Intellisense.Elixir.handle_request({:completion, "@attr.value"}, context, node())
+    end
+
+    test "includes language keywords" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "nil",
+                   kind: :keyword,
+                   documentation: "(special atom)",
+                   insert_text: "nil"
+                 }
+                 | _
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "nil"}, context, node())
+    end
+
+    test "includes space instead of parentheses for def* macros" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "defmodule/2",
+                   insert_text: "defmodule "
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "defmodu"}, context, node())
+    end
+
+    test "includes space instead of parentheses for keyword macros" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "import/2",
+                   insert_text: "import "
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "impor"}, context, node())
+    end
+
+    test "includes doesn't include space nor parentheses for macros like __ENV__" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "__ENV__/0",
+                   insert_text: "__ENV__"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "__EN"}, context, node())
+    end
+
+    test "Elixir bitstring modifiers" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "integer",
+                   kind: :type,
+                   documentation: "(bitstring option)",
+                   insert_text: "integer"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "<<a::intege"}, context, node())
+
+      assert %{
+               items: [
+                 %{
+                   label: "size",
+                   kind: :type,
+                   documentation: "(bitstring option)",
+                   insert_text: "size(${})"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "<<a::siz"}, context, node())
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "<<a::"}, context, node())
+
+      assert %{
+               label: "integer",
+               kind: :type,
+               documentation: "(bitstring option)",
+               insert_text: "integer"
+             } in items
+    end
+
+    test "completion for aliases in special forms" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "Range",
+                   kind: :struct,
+                   documentation: """
+                   Returns an inclusive range between dates.
+
+                   (struct)\
+                   """,
+                   insert_text: "Range"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "alias Date."}, context, node())
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "alias "}, context, node())
+
+      assert %{
+               label: "Atom",
+               kind: :module,
+               documentation: """
+               Atoms are constants whose values are their own name.
+
+               (module)\
+               """,
+               insert_text: "Atom"
+             } in items
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "alias "}, context, node())
+
+      refute Enum.any?(items, &(&1.kind == :function))
+    end
+  end
+
+  describe "details" do
+    test "returns nil if there are no matches" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert nil ==
+               Intellisense.Elixir.handle_request(
+                 {:details, "Unknown.unknown()", 2},
+                 context,
+                 node()
+               )
+    end
+
+    test "returns subject range" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{range: %{from: 1, to: 18}} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "Integer.to_string(10)", 15},
+                 context,
+                 node()
+               )
+
+      assert %{range: %{from: 1, to: 8}} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "Integer.to_string(10)", 2},
+                 context,
+                 node()
+               )
+    end
+
+    test "does not return duplicate details for functions with default arguments" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [_]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "Integer.to_string(10)", 15},
+                 context,
+                 node()
+               )
+    end
+
+    test "returns details only for exactly matching identifiers" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert nil == Intellisense.Elixir.handle_request({:details, "Enum.ma", 6}, context, node())
+    end
+
+    test "returns full docs" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request({:details, "Enum.map", 6}, context, node())
+
+      assert content =~ "## Examples"
+    end
+
+    test "returns deprecated docs" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [content | _]} =
+               Intellisense.Elixir.handle_request({:details, "Enum.chunk", 6}, context, node())
+
+      assert content =~ "Use Enum.chunk_every/2 instead"
+    end
+
+    test "returns since docs" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request({:details, "then", 2}, context, node())
+
+      assert content =~ "Since 1.12.0"
+    end
+
+    @tag :erl_docs
+    test "returns full Erlang docs" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [file]} =
+               Intellisense.Elixir.handle_request({:details, ":file.read()", 2}, context, node())
+
+      assert file =~ "## Performance"
+
+      assert %{contents: [file_read]} =
+               Intellisense.Elixir.handle_request({:details, ":file.read()", 8}, context, node())
+
+      assert file_read =~ "Typical error reasons:"
+
+      assert %{contents: [crypto]} =
+               Intellisense.Elixir.handle_request({:details, ":crypto", 5}, context, node())
+
+      assert crypto =~ "This module provides a set of cryptographic functions."
+    end
+
+    test "properly parses unicode" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert nil ==
+               Intellisense.Elixir.handle_request({:details, "msg = '🍵'", 8}, context, node())
+    end
+
+    test "handles operators" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [match_op]} =
+               Intellisense.Elixir.handle_request({:details, "x = 1", 3}, context, node())
+
+      assert match_op =~ "Match operator."
+    end
+
+    test "handles local calls" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [to_string_fn]} =
+               Intellisense.Elixir.handle_request({:details, "to_string(1)", 3}, context, node())
+
+      assert to_string_fn =~ "Converts the argument to a string"
+    end
+
+    test "returns nil for bitstring modifiers" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert nil ==
+               Intellisense.Elixir.handle_request(
+                 {:details, "<<x :: integer>>", 6},
+                 context,
+                 node()
+               )
+
+      assert nil ==
+               Intellisense.Elixir.handle_request(
+                 {:details, "<<x :: integer>>", 10},
+                 context,
+                 node()
+               )
+    end
+
+    test "includes full module name in the docs" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [date_range]} =
+               Intellisense.Elixir.handle_request({:details, "Date.Range", 8}, context, node())
+
+      assert date_range =~ "Date.Range"
+    end
+
+    test "returns module-prepended type signatures" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [type]} =
+               Intellisense.Elixir.handle_request({:details, "Date.t", 6}, context, node())
+
+      assert type =~ "Date.t()"
+    end
+
+    @tag :erl_docs
+    test "returns module-prepended Erlang type signatures" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [type]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, ":code.load_error_rsn", 8},
+                 context,
+                 node()
+               )
+
+      assert type =~ ":code.load_error_rsn()"
+    end
+
+    test "includes type specs" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [type]} =
+               Intellisense.Elixir.handle_request({:details, "Date.t", 6}, context, node())
+
+      assert type =~ "@type t() :: %Date"
+
+      # opaque types are listed without internal definition
+      assert %{contents: [type]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "MapSet.internal", 10},
+                 context,
+                 node()
+               )
+
+      assert type =~ "@opaque internal(value)\n"
+    end
+
+    @tag :erl_docs
+    test "includes Erlang type specs" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [type]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, ":code.load_error_rsn", 8},
+                 context,
+                 node()
+               )
+
+      assert type =~ "@type load_error_rsn() ::"
+    end
+
+    test "returns link to online documentation" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request({:details, "Integer", 1}, context, node())
+
+      assert content =~ ~r"https://hexdocs.pm/elixir/[^/]+/Integer.html"
+
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "Integer.to_string(10)", 15},
+                 context,
+                 node()
+               )
+
+      assert content =~ ~r"https://hexdocs.pm/elixir/[^/]+/Integer.html#to_string/2"
+
+      # test elixir types
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "GenServer.on_start", 12},
+                 context,
+                 node()
+               )
+
+      assert content =~ ~r"https://hexdocs.pm/elixir/[^/]+/GenServer.html#t:on_start/0"
+
+      # test erlang types
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, ":code.load_ret", 7},
+                 context,
+                 node()
+               )
+
+      assert content =~ ~r"https://www.erlang.org/doc/man/code.html#type-load_ret"
+
+      # test erlang modules on hexdocs
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, ":telemetry.span", 13},
+                 context,
+                 node()
+               )
+
+      assert content =~ ~r"https://hexdocs.pm/telemetry/[^/]+/telemetry.html#span/3"
+
+      # test erlang applications
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request({:details, ":code", 3}, context, node())
+
+      assert content =~ ~r"https://www.erlang.org/doc/man/code.html"
+
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, ":code.load_binary", 10},
+                 context,
+                 node()
+               )
+
+      assert content =~ ~r"https://www.erlang.org/doc/man/code.html#load_binary-3"
+
+      # test erlang modules
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request({:details, ":atomics.new", 11}, context, node())
+
+      assert content =~ ~r"https://www.erlang.org/doc/man/atomics.html#new-2"
+
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request(
+                 {:details, ":string.uppercase", 11},
+                 context,
+                 node()
+               )
+
+      assert content =~ ~r"https://www.erlang.org/doc/man/string.html#uppercase-1"
+    end
+
+    @tag :tmp_dir
+    test "includes definition location for runtime modules", %{tmp_dir: tmp_dir} do
+      Code.put_compiler_option(:debug_info, true)
+
+      context =
+        intellisense_context_from_eval tmp_dir do
+          alias Livebook.Intellisense.ElixirTest.GoToDefinition
+        end
+
+      code = ~S'''
+      defmodule Livebook.Intellisense.ElixirTest.GoToDefinition do
+        @type t :: term()
+        @type foo :: foo(:bar)
+        @type foo(var) :: {var, t()}
+
+        defmacro with_logging(do: block) do
+          quote do
+            require Logger
+            Logger.debug("Running code")
+            result = unquote(block)
+            Logger.debug("Result: #{inspect(result)}")
+            result
+          end
+        end
+
+        @spec hello(var :: term()) :: foo(term())
+        def hello(message) do
+          {:bar, message}
+        end
+      end
+      '''
+
+      file = "#{__ENV__.file}#cell:#{Livebook.Utils.random_short_id()}"
+      compile_and_save_bytecode(tmp_dir, code, file)
+
+      assert %{definition: %{line: 1, file: ^file}} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "GoToDefinition", 14},
+                 context,
+                 node()
+               )
+
+      assert %{definition: %{line: 2, file: ^file}} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "GoToDefinition.t", 16},
+                 context,
+                 node()
+               )
+
+      # Currently we are fetching location of the lowest arity
+      assert %{definition: %{line: 3, file: ^file}} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "GoToDefinition.foo", 18},
+                 context,
+                 node()
+               )
+
+      assert %{definition: %{line: 6, file: ^file}} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "GoToDefinition.with_logging", 20},
+                 context,
+                 node()
+               )
+
+      assert %{definition: %{line: 17, file: ^file}} =
+               Intellisense.Elixir.handle_request(
+                 {:details, "GoToDefinition.hello", 18},
+                 context,
+                 node()
+               )
+    after
+      Code.put_compiler_option(:debug_info, false)
+    end
+  end
+
+  describe "signature" do
+    test "returns nil when outside call" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert nil == Intellisense.Elixir.handle_request({:signature, "length()"}, context, node())
+    end
+
+    test "returns nil if there are no matches" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert nil ==
+               Intellisense.Elixir.handle_request(
+                 {:signature, "Unknown.unknown("},
+                 context,
+                 node()
+               )
+
+      assert nil ==
+               Intellisense.Elixir.handle_request(
+                 {:signature, "Enum.concat(x, y,"},
+                 context,
+                 node()
+               )
+    end
+
+    test "supports remote function calls" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: "map(enumerable, fun)",
+                   arguments: ["enumerable", "fun"]
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:signature, "Enum.map("}, context, node())
+    end
+
+    test "supports local function calls" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: "length(list)",
+                   arguments: ["list"]
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:signature, "length("}, context, node())
+    end
+
+    test "supports manually imported functions and macros" do
+      context =
+        intellisense_context_from_eval do
+          import Enum
+          import Protocol
+        end
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: "map(enumerable, fun)",
+                   arguments: ["enumerable", "fun"]
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:signature, "map("}, context, node())
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: ~S"derive(protocol, module, options \\ [])",
+                   arguments: ["protocol", "module", ~S"options \\ []"]
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:signature, "derive("}, context, node())
+    end
+
+    test "supports remote function calls on aliases" do
+      context =
+        intellisense_context_from_eval do
+          alias Enum, as: MyEnum
+        end
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: "map(enumerable, fun)",
+                   arguments: ["enumerable", "fun"]
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:signature, "MyEnum.map("}, context, node())
+    end
+
+    test "supports anonymous function calls" do
+      context =
+        intellisense_context_from_eval do
+          add = fn x, y -> x + y end
+        end
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: "add.(arg1, arg2)",
+                   arguments: ["arg1", "arg2"]
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:signature, "add.("}, context, node())
+    end
+
+    test "supports captured remote function calls" do
+      context =
+        intellisense_context_from_eval do
+          map = &Enum.map/2
+        end
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: "map(enumerable, fun)",
+                   arguments: ["enumerable", "fun"]
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:signature, "map.("}, context, node())
+    end
+
+    @tag :erl_docs
+    test "shows signature with arguments for erlang modules" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: "map(Fun, List1)",
+                   arguments: ["Fun", "List1"]
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:signature, ":lists.map("}, context, node())
+    end
+
+    test "shows signature with default argument being an anonymous function" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               active_argument: 3,
+               items: [
+                 %{
+                   signature:
+                     ~S"max_by(enumerable, fun, sorter \\ &>=/2, empty_fallback \\ fn -> raise Enum.EmptyError end)",
+                   arguments: [
+                     "enumerable",
+                     "fun",
+                     ~S"sorter \\ &>=/2",
+                     ~S"empty_fallback \\ fn -> raise Enum.EmptyError end"
+                   ]
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:signature, "Enum.max_by([1, 2], &Kernel.-/1, &>=/2, "},
+                 context,
+                 node()
+               )
+    end
+
+    test "returns call active argument" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{active_argument: 0, items: [_item]} =
+               Intellisense.Elixir.handle_request({:signature, "Enum.map([1, "}, context, node())
+
+      assert %{active_argument: 1, items: [_item]} =
+               Intellisense.Elixir.handle_request(
+                 {:signature, "Enum.map([1, 2], "},
+                 context,
+                 node()
+               )
+
+      assert %{active_argument: 1, items: [_item]} =
+               Intellisense.Elixir.handle_request(
+                 {:signature, "Enum.map([1, 2], fn x -> x * x end"},
+                 context,
+                 node()
+               )
+
+      assert %{active_argument: 2, items: [_item]} =
+               Intellisense.Elixir.handle_request(
+                 {:signature, "IO.ANSI.color(1, 2, 3"},
+                 context,
+                 node()
+               )
+
+      assert %{active_argument: 1, items: [_item]} =
+               Intellisense.Elixir.handle_request({:signature, "elem(x, 1 + "}, context, node())
+    end
+
+    test "returns correct active argument when using pipe operator" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{active_argument: 1, items: [_item]} =
+               Intellisense.Elixir.handle_request(
+                 {:signature, "[1, 2] |> Enum.map("},
+                 context,
+                 node()
+               )
+
+      assert %{active_argument: 1, items: [_item]} =
+               Intellisense.Elixir.handle_request(
+                 {:signature, "[1, 2] |> Enum.map(fn x -> x * x end"},
+                 context,
+                 node()
+               )
+
+      assert %{active_argument: 2, items: [_item]} =
+               Intellisense.Elixir.handle_request(
+                 {:signature, "1 |> IO.ANSI.color(2, 3"},
+                 context,
+                 node()
+               )
+    end
+
+    test "returns a single signature for functions with default arguments" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: ~S"to_string(integer, base \\ 10)",
+                   arguments: ["integer", ~S"base \\ 10"]
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:signature, "Integer.to_string("},
+                 context,
+                 node()
+               )
+    end
+
+    test "returns multiple signatures for function with multiple arities" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   signature: "concat(enumerables)",
+                   arguments: ["enumerables"]
+                 },
+                 %{
+                   signature: "concat(left, right)",
+                   arguments: ["left", "right"]
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:signature, "Enum.concat("}, context, node())
+    end
+
+    test "returns only signatures where active argument is at valid position" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               active_argument: 1,
+               items: [
+                 %{
+                   signature: "concat(left, right)",
+                   arguments: ["left", "right"]
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request(
+                 {:signature, "Enum.concat([1, 2], "},
+                 context,
+                 node()
+               )
+    end
+
+    test "does not return any signatures when in do-end block" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert nil ==
+               Intellisense.Elixir.handle_request({:signature, "if true do "}, context, node())
+    end
+
+    test "does not return any signatures for module attributes" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert nil == Intellisense.Elixir.handle_request({:signature, "@length("}, context, node())
+    end
+
+    test "does not returns signatures for calls in attribute value" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               active_argument: 0,
+               items: [
+                 %{
+                   arguments: ["list"],
+                   signature: "length(list)"
+                 }
+               ]
+             } =
+               Intellisense.Elixir.handle_request({:signature, "@attr length("}, context, node())
+    end
+  end
+
+  # Remote intellisense tests
+
+  setup_all do
+    # We use the standalone runtime to mimic a remote node. Note that
+    # in the past we used :peer.start, but it was often failing on CI
+    # (the start was timing out)
+
+    pid = Livebook.Runtime.Standalone.new() |> Livebook.Runtime.connect()
+    assert_receive {:runtime_connect_done, ^pid, {:ok, runtime}}
+
+    parent = self()
+
+    runtime_owner_pid =
+      start_supervised!({
+        Task,
+        fn ->
+          Livebook.Runtime.take_ownership(runtime)
+
+          code =
+            ~S'''
+            defmodule RemoteModule do
+              @moduledoc """
+              RemoteModule module docs
+              """
+
+              @doc """
+              Hello doc
+              """
+              def hello(message) do
+                message
+              end
+            end
+            '''
+
+          Livebook.Runtime.evaluate_code(runtime, :elixir, code, {:c1, :e1}, [])
+          receive do: ({:runtime_evaluation_response, :e1, _, _} -> :ok)
+          send(parent, :continue)
+
+          receive do: (:done -> :ok)
+        end
+      })
+
+    receive do: (:continue -> :ok)
+
+    on_exit(fn ->
+      send(runtime_owner_pid, :done)
+    end)
+
+    [node: runtime.node]
+  end
+
+  describe "intellisense completion for remote nodes" do
+    test "do not find the RemoteModule inside the Livebook node" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: []} ==
+               Intellisense.Elixir.handle_request({:completion, "RemoteModule"}, context, node())
+    end
+
+    test "find the RemoteModule and its docs", %{node: node} do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "RemoteModule"}, context, node)
+
+      assert %{
+               label: "RemoteModule",
+               kind: :module,
+               documentation: """
+               No documentation available
+
+               (module)\
+               """,
+               insert_text: "RemoteModule"
+             } in items
+    end
+
+    test "find RemoteModule exported functions and its docs", %{node: node} do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request(
+                 {:completion, "RemoteModule.hel"},
+                 context,
+                 node
+               )
+
+      assert %{
+               label: "hello/1",
+               kind: :function,
+               documentation: """
+               No documentation available
+
+               ```
+               RemoteModule.hello(arg1)
+               ```\
+               """,
+               insert_text: "hello(${})"
+             } in items
+    end
+
+    @tag :erl_docs
+    test "find modules from apps", %{node: node} do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{
+                   label: "unsubscribe/1",
+                   kind: :function,
+                   documentation: """
+                   No documentation available
+
+                   ```
+                   :mnesia.unsubscribe(arg1)
+                   ```\
+                   """,
+                   insert_text: "unsubscribe(${})"
+                 }
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, ":mnesia.unsub"}, context, node)
+    end
+
+    test "get details", %{node: node} do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{contents: [content]} =
+               Intellisense.Elixir.handle_request({:details, "RemoteModule", 6}, context, node)
+
+      assert content =~ "No documentation available"
+    end
+  end
+
+  defp compile_and_save_bytecode(dir, code, file \\ "nofile") do
+    [{module, bytecode}] = Code.compile_string(code, file)
+    path = Path.join(dir, "#{module}.beam")
+
+    File.write!(path, bytecode)
+    Code.prepend_path(dir)
+
+    on_exit(fn ->
+      Code.delete_path(dir)
+      :code.purge(module)
+      :code.delete(module)
+    end)
+  end
+end
diff --git a/test/livebook/intellisense_test.exs b/test/livebook/intellisense_test.exs
deleted file mode 100644
index 714258478..000000000
--- a/test/livebook/intellisense_test.exs
+++ /dev/null
@@ -1,2079 +0,0 @@
-defmodule Livebook.IntellisenseTest do
-  use ExUnit.Case, async: true
-
-  alias Livebook.Intellisense
-
-  # Returns intellisense context resulting from evaluating
-  # the given block of code in a fresh context.
-  defmacrop eval(ebin_path \\ System.tmp_dir!(), do: block) do
-    quote do
-      block = unquote(Macro.escape(block))
-      binding = []
-      env = Code.env_for_eval([])
-      {value, binding, env} = Code.eval_quoted_with_env(block, binding, env)
-
-      %{
-        env: env,
-        ebin_path: unquote(ebin_path),
-        map_binding: fn fun -> fun.(binding) end
-      }
-    end
-  end
-
-  setup do
-    Intellisense.clear_cache(node())
-    :ok
-  end
-
-  describe "format_code/1" do
-    test "formats valid code" do
-      assert %{code: "1 + 1", code_markers: []} = Intellisense.format_code("1+1")
-    end
-
-    test "returns a syntax error when invalid code is given" do
-      assert %{
-               code: nil,
-               code_markers: [
-                 %{
-                   line: 1,
-                   description: "syntax error: expression is incomplete",
-                   severity: :error
-                 }
-               ]
-             } = Intellisense.format_code("1+")
-    end
-  end
-
-  describe "get_completion_items/3" do
-    test "completion when no hint given" do
-      context = eval(do: nil)
-
-      length_item = %{
-        label: "length/1",
-        kind: :function,
-        documentation: """
-        Returns the length of `list`.
-
-        ```
-        Kernel.length(list)
-        ```\
-        """,
-        insert_text: "length(${})"
-      }
-
-      assert length_item in Intellisense.get_completion_items("", context, node())
-      assert length_item in Intellisense.get_completion_items("to_string(", context, node())
-      assert length_item in Intellisense.get_completion_items("Enum.map(list, ", context, node())
-    end
-
-    @tag :erl_docs
-    test "Erlang module completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: ":zlib",
-                 kind: :module,
-                 documentation: """
-                 zlib compression interface.
-
-                 (module)\
-                 """,
-                 insert_text: "zlib"
-               }
-             ] = Intellisense.get_completion_items(":zl", context, node())
-    end
-
-    test "Erlang module no completion" do
-      context = eval(do: nil)
-
-      assert [] = Intellisense.get_completion_items(":unknown", context, node())
-    end
-
-    test "Erlang module multiple values completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: ":orddict",
-                 kind: :module,
-                 documentation: _orddict_doc,
-                 insert_text: "orddict"
-               },
-               %{
-                 label: ":ordsets",
-                 kind: :module,
-                 documentation: _ordsets_doc,
-                 insert_text: "ordsets"
-               }
-             ] = Intellisense.get_completion_items(":ord", context, node())
-    end
-
-    @tag :erl_docs
-    test "Erlang root completion" do
-      context = eval(do: nil)
-
-      lists_item = %{
-        label: ":lists",
-        kind: :module,
-        documentation: """
-        List processing functions.
-
-        (module)\
-        """,
-        insert_text: "lists"
-      }
-
-      assert lists_item in Intellisense.get_completion_items(":", context, node())
-      assert lists_item in Intellisense.get_completion_items("  :", context, node())
-    end
-
-    @tag :erl_docs
-    test "Erlang completion doesn't include quoted atoms" do
-      context = eval(do: nil)
-
-      assert [] = Intellisense.get_completion_items(~s{:Elixir}, context, node())
-    end
-
-    @tag :erl_docs
-    test "Erlang module completion with 'in' operator in spec" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "open_port/2",
-                 kind: :function,
-                 documentation: _open_port_doc,
-                 insert_text: "open_port(${})"
-               }
-             ] = Intellisense.get_completion_items(":erlang.open_por", context, node())
-    end
-
-    @tag :erl_docs
-    test "Erlang type completion" do
-      context = eval(do: nil)
-
-      items = Intellisense.get_completion_items(":maps.iterator", context, node())
-
-      assert %{
-               label: "iterator/0",
-               kind: :type,
-               documentation: """
-               No documentation available
-
-               ```
-               @type iterator() :: iterator(term(), term())
-               ```\
-               """,
-               insert_text: "iterator()"
-             } in items
-
-      assert %{
-               label: "iterator/2",
-               kind: :type,
-               documentation: """
-               An iterator representing the associations in a map with keys of type `Key` and
-               values of type `Value`.
-
-               ```
-               @opaque iterator(key, value)
-               ```\
-               """,
-               insert_text: "iterator(${})"
-             } in items
-    end
-
-    test "Elixir proxy" do
-      context = eval(do: nil)
-
-      assert %{
-               label: "Elixir",
-               kind: :module,
-               documentation: """
-               No documentation available
-
-               (module)\
-               """,
-               insert_text: "Elixir"
-             } in Intellisense.get_completion_items("Eli", context, node())
-    end
-
-    test "Elixir module completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "Enum",
-                 kind: :module,
-                 documentation: """
-                 Functions for working with collections (known as enumerables).
-
-                 (module)\
-                 """,
-                 insert_text: "Enum"
-               },
-               %{
-                 label: "Enumerable",
-                 kind: :interface,
-                 documentation: """
-                 Enumerable protocol used by `Enum` and `Stream` modules.
-
-                 (protocol)\
-                 """,
-                 insert_text: "Enumerable"
-               }
-             ] = Intellisense.get_completion_items("En", context, node())
-
-      assert [
-               %{
-                 label: "Enumerable",
-                 kind: :interface,
-                 documentation: """
-                 Enumerable protocol used by `Enum` and `Stream` modules.
-
-                 (protocol)\
-                 """,
-                 insert_text: "Enumerable"
-               }
-             ] = Intellisense.get_completion_items("Enumera", context, node())
-
-      assert [
-               %{
-                 label: "RuntimeError",
-                 kind: :struct,
-                 documentation: """
-                 An exception for a generic runtime error.
-
-                 (exception)\
-                 """,
-                 insert_text: "RuntimeError"
-               }
-             ] = Intellisense.get_completion_items("RuntimeE", context, node())
-    end
-
-    test "Elixir struct completion lists nested options" do
-      context = eval(do: nil)
-
-      assert %{
-               label: "File.Stat",
-               kind: :struct,
-               documentation: """
-               A struct that holds file information.
-
-               (struct)\
-               """,
-               insert_text: "File.Stat"
-             } in Intellisense.get_completion_items("%Fi", context, node())
-    end
-
-    test "Elixir type completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "from/0",
-                 kind: :type,
-                 documentation: """
-                 Tuple describing the client of a call request.
-
-                 ```
-                 @type from() :: {pid(), tag :: term()}
-                 ```\
-                 """,
-                 insert_text: "from()"
-               }
-             ] = Intellisense.get_completion_items("GenServer.fr", context, node())
-
-      assert [
-               %{
-                 label: "internal/1",
-                 kind: :type,
-                 documentation: """
-                 No documentation available
-
-                 ```
-                 @opaque internal(value)
-                 ```\
-                 """,
-                 insert_text: "internal(${})"
-               }
-             ] = Intellisense.get_completion_items("MapSet.intern", context, node())
-    end
-
-    test "Elixir module completion with self" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "Enumerable",
-                 kind: :interface,
-                 documentation: """
-                 Enumerable protocol used by `Enum` and `Stream` modules.
-
-                 (protocol)\
-                 """,
-                 insert_text: "Enumerable"
-               }
-             ] = Intellisense.get_completion_items("Enumerable", context, node())
-    end
-
-    test "Elixir completion on modules from load path" do
-      context = eval(do: nil)
-
-      assert %{
-               label: "Req",
-               kind: :module,
-               documentation: """
-               The high-level API.
-
-               (module)\
-               """,
-               insert_text: "Req"
-             } in Intellisense.get_completion_items("R", context, node())
-    end
-
-    test "Elixir no completion" do
-      context = eval(do: nil)
-
-      assert [] = Intellisense.get_completion_items(".", context, node())
-      assert [] = Intellisense.get_completion_items("Xyz", context, node())
-      assert [] = Intellisense.get_completion_items("x.Foo", context, node())
-      assert [] = Intellisense.get_completion_items("x.Foo.get_by", context, node())
-    end
-
-    test "Elixir private module no completion" do
-      context = eval(do: nil)
-
-      assert [] = Intellisense.get_completion_items("Livebook.TestModules.Hidd", context, node())
-    end
-
-    test "Elixir private module members completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "visible/0",
-                 kind: :function,
-                 documentation: """
-                 No documentation available
-
-                 ```
-                 Livebook.TestModules.Hidden.visible()
-                 ```\
-                 """,
-                 insert_text: "visible()"
-               }
-             ] =
-               Intellisense.get_completion_items("Livebook.TestModules.Hidden.", context, node())
-    end
-
-    test "Elixir root submodule completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "Access",
-                 kind: :interface,
-                 documentation: """
-                 Key-based access to data structures.
-
-                 (behaviour)\
-                 """,
-                 insert_text: "Access"
-               }
-             ] = Intellisense.get_completion_items("Elixir.Acce", context, node())
-    end
-
-    test "Elixir submodule completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "ANSI",
-                 kind: :module,
-                 documentation: """
-                 Functionality to render ANSI escape sequences.
-
-                 (module)\
-                 """,
-                 insert_text: "ANSI"
-               }
-             ] = Intellisense.get_completion_items("IO.AN", context, node())
-    end
-
-    test "Elixir submodule no completion" do
-      context = eval(do: nil)
-
-      assert [] = Intellisense.get_completion_items("IEx.Xyz", context, node())
-    end
-
-    test "Elixir function completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "version/0",
-                 kind: :function,
-                 documentation: """
-                 Elixir version information.
-
-                 ```
-                 System.version()
-                 ```\
-                 """,
-                 insert_text: "version()"
-               }
-             ] = Intellisense.get_completion_items("System.ve", context, node())
-    end
-
-    test "Elixir sigil completion" do
-      context = eval(do: nil)
-
-      regex_item = %{
-        label: "~r/2",
-        kind: :function,
-        documentation: """
-        Handles the sigil `~r` for regular expressions.
-
-        ```
-        Kernel.sigil_r(term, modifiers)
-        ```\
-        """,
-        insert_text: "~r"
-      }
-
-      assert regex_item in Intellisense.get_completion_items("~", context, node())
-
-      assert [^regex_item] = Intellisense.get_completion_items("~r", context, node())
-    end
-
-    @tag :erl_docs
-    test "Erlang function completion" do
-      context = eval(do: nil)
-
-      assert %{
-               label: "gzip/1",
-               kind: :function,
-               documentation: """
-               Compresses data with gz headers and checksum.
-
-               ```
-               :zlib.gzip(Data)
-               ```\
-               """,
-               insert_text: "gzip(${})"
-             } in Intellisense.get_completion_items(":zlib.gz", context, node())
-    end
-
-    test "function completion with arity" do
-      context = eval(do: nil)
-
-      assert %{
-               label: "concat/1",
-               kind: :function,
-               documentation: """
-               Given an enumerable of enumerables, concatenates the `enumerables` into
-               a single list.
-
-               ```
-               Enum.concat(enumerables)
-               ```\
-               """,
-               insert_text: "concat(${})"
-             } in Intellisense.get_completion_items("Enum.concat/", context, node())
-
-      assert [
-               %{label: "count/1"},
-               %{label: "count/2"}
-             ] = Intellisense.get_completion_items("Enum.count/", context, node())
-    end
-
-    test "function completion same name with different arities" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "concat/1",
-                 kind: :function,
-                 documentation: """
-                 Given an enumerable of enumerables, concatenates the `enumerables` into
-                 a single list.
-
-                 ```
-                 Enum.concat(enumerables)
-                 ```\
-                 """,
-                 insert_text: "concat(${})"
-               },
-               %{
-                 label: "concat/2",
-                 kind: :function,
-                 documentation: """
-                 Concatenates the enumerable on the `right` with the enumerable on the
-                 `left`.
-
-                 ```
-                 Enum.concat(left, right)
-                 ```\
-                 """,
-                 insert_text: "concat(${})"
-               }
-             ] = Intellisense.get_completion_items("Enum.concat", context, node())
-    end
-
-    test "function completion when has default args then documentation all arities have docs" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "utc_today/0",
-                 kind: :function,
-                 documentation: """
-                 Returns the current date in UTC.
-
-                 ```
-                 Date.utc_today(calendar \\\\ Calendar.ISO)
-                 ```\
-                 """,
-                 insert_text: "utc_today()"
-               },
-               %{
-                 label: "utc_today/1",
-                 kind: :function,
-                 documentation: """
-                 Returns the current date in UTC.
-
-                 ```
-                 Date.utc_today(calendar \\\\ Calendar.ISO)
-                 ```\
-                 """,
-                 insert_text: "utc_today(${})"
-               }
-             ] = Intellisense.get_completion_items("Date.utc", context, node())
-    end
-
-    test "function completion using a variable bound to a module" do
-      context =
-        eval do
-          mod = System
-        end
-
-      assert [
-               %{
-                 label: "version/0",
-                 kind: :function,
-                 documentation: """
-                 Elixir version information.
-
-                 ```
-                 System.version()
-                 ```\
-                 """,
-                 insert_text: "version()"
-               }
-             ] = Intellisense.get_completion_items("mod.ve", context, node())
-    end
-
-    test "operator completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "++/2",
-                 kind: :function,
-                 documentation: """
-                 List concatenation operator. Concatenates a proper list and a term, returning a list.
-
-                 ```
-                 left ++ right
-                 ```\
-                 """,
-                 insert_text: "++"
-               },
-               %{
-                 label: "+/1",
-                 kind: :function,
-                 documentation: """
-                 Arithmetic positive unary operator.
-
-                 ```
-                 +value
-                 ```\
-                 """,
-                 insert_text: "+"
-               },
-               %{
-                 label: "+/2",
-                 kind: :function,
-                 documentation: """
-                 Arithmetic addition operator.
-
-                 ```
-                 left + right
-                 ```\
-                 """,
-                 insert_text: "+"
-               }
-             ] = Intellisense.get_completion_items("+", context, node())
-
-      assert [
-               %{label: "+/1"},
-               %{label: "+/2"}
-             ] = Intellisense.get_completion_items("+/", context, node())
-
-      assert [
-               %{label: "++/2"}
-             ] = Intellisense.get_completion_items("++/", context, node())
-    end
-
-    test "map atom key completion" do
-      context =
-        eval do
-          map = %{
-            foo: 1,
-            bar_1: ~r/pattern/,
-            bar_2: true
-          }
-        end
-
-      assert [
-               %{
-                 label: "bar_1",
-                 kind: :field,
-                 documentation: "(field)",
-                 insert_text: "bar_1"
-               },
-               %{
-                 label: "bar_2",
-                 kind: :field,
-                 documentation: "(field)",
-                 insert_text: "bar_2"
-               },
-               %{
-                 label: "foo",
-                 kind: :field,
-                 documentation: "(field)",
-                 insert_text: "foo"
-               }
-             ] = Intellisense.get_completion_items("map.", context, node())
-
-      assert [
-               %{
-                 label: "foo",
-                 kind: :field,
-                 documentation: "(field)",
-                 insert_text: "foo"
-               }
-             ] = Intellisense.get_completion_items("map.f", context, node())
-    end
-
-    test "nested map atom key completion" do
-      context =
-        eval do
-          map = %{
-            nested: %{
-              deeply: %{
-                foo: 1,
-                bar_1: 23,
-                bar_2: 14,
-                mod: System
-              }
-            }
-          }
-        end
-
-      assert [
-               %{
-                 label: "nested",
-                 kind: :field,
-                 documentation: "(field)",
-                 insert_text: "nested"
-               }
-             ] = Intellisense.get_completion_items("map.nest", context, node())
-
-      assert [
-               %{
-                 label: "foo",
-                 kind: :field,
-                 documentation: "(field)",
-                 insert_text: "foo"
-               }
-             ] = Intellisense.get_completion_items("map.nested.deeply.f", context, node())
-
-      assert [
-               %{
-                 label: "version/0",
-                 kind: :function,
-                 documentation: """
-                 Elixir version information.
-
-                 ```
-                 System.version()
-                 ```\
-                 """,
-                 insert_text: "version()"
-               }
-             ] = Intellisense.get_completion_items("map.nested.deeply.mod.ve", context, node())
-
-      assert [] = Intellisense.get_completion_items("map.non.existent", context, node())
-    end
-
-    test "map string key completion is not supported" do
-      context =
-        eval do
-          map = %{"foo" => 1}
-        end
-
-      assert [] = Intellisense.get_completion_items("map.f", context, node())
-    end
-
-    test "autocompletion off a bound variable only works for modules and maps" do
-      context =
-        eval do
-          num = 5
-          map = %{nested: %{num: 23}}
-        end
-
-      assert [] = Intellisense.get_completion_items("num.print", context, node())
-      assert [] = Intellisense.get_completion_items("map.nested.num.f", context, node())
-    end
-
-    test "autocompletion using access syntax does is not supported" do
-      context =
-        eval do
-          map = %{nested: %{deeply: %{num: 23}}}
-        end
-
-      assert [] = Intellisense.get_completion_items("map[:nested][:deeply].n", context, node())
-      assert [] = Intellisense.get_completion_items("map[:nested].deeply.n", context, node())
-      assert [] = Intellisense.get_completion_items("map.nested.[:deeply].n", context, node())
-    end
-
-    test "macro completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "is_nil/1",
-                 kind: :function,
-                 documentation: """
-                 Returns `true` if `term` is `nil`, `false` otherwise.
-
-                 ```
-                 Kernel.is_nil(term)
-                 ```\
-                 """,
-                 insert_text: "is_nil(${})"
-               }
-             ] = Intellisense.get_completion_items("Kernel.is_ni", context, node())
-    end
-
-    test "special forms completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "quote/2",
-                 kind: :function,
-                 documentation: """
-                 Gets the representation of any expression.
-
-                 ```
-                 Kernel.SpecialForms.quote(opts, block)
-                 ```\
-                 """,
-                 insert_text: "quote "
-               }
-             ] = Intellisense.get_completion_items("quot", context, node())
-    end
-
-    test "kernel import completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "put_in/2",
-                 kind: :function,
-                 documentation: """
-                 Puts a value in a nested structure via the given `path`.
-
-                 ```
-                 Kernel.put_in(path, value)
-                 ```\
-                 """,
-                 insert_text: "put_in(${})"
-               },
-               %{
-                 label: "put_in/3",
-                 kind: :function,
-                 documentation: """
-                 Puts a value in a nested structure.
-
-                 ```
-                 Kernel.put_in(data, keys, value)
-                 ```\
-                 """,
-                 insert_text: "put_in(${})"
-               }
-             ] = Intellisense.get_completion_items("put_i", context, node())
-    end
-
-    test "variable name completion" do
-      context =
-        eval do
-          number = 3
-          numbats = ["numbat", "numbat"]
-          nothing = nil
-        end
-
-      assert [
-               %{
-                 label: "numbats",
-                 kind: :variable,
-                 documentation: "(variable)",
-                 insert_text: "numbats"
-               }
-             ] = Intellisense.get_completion_items("numba", context, node())
-
-      assert [
-               %{
-                 label: "numbats",
-                 kind: :variable,
-                 documentation: "(variable)",
-                 insert_text: "numbats"
-               },
-               %{
-                 label: "number",
-                 kind: :variable,
-                 documentation: "(variable)",
-                 insert_text: "number"
-               }
-             ] = Intellisense.get_completion_items("num", context, node())
-
-      assert [
-               %{
-                 label: "nothing",
-                 kind: :variable,
-                 documentation: "(variable)",
-                 insert_text: "nothing"
-               },
-               %{label: "node/0"},
-               %{label: "node/1"},
-               %{label: "not/1"}
-             ] = Intellisense.get_completion_items("no", context, node())
-    end
-
-    test "completion of manually imported functions and macros" do
-      context =
-        eval do
-          import Enum
-          import System, only: [version: 0]
-          import Protocol
-        end
-
-      assert [
-               %{label: "take/2"},
-               %{label: "take_every/2"},
-               %{label: "take_random/2"},
-               %{label: "take_while/2"}
-             ] = Intellisense.get_completion_items("take", context, node())
-
-      assert %{
-               label: "version/0",
-               kind: :function,
-               documentation: """
-               Elixir version information.
-
-               ```
-               System.version()
-               ```\
-               """,
-               insert_text: "version()"
-             } in Intellisense.get_completion_items("v", context, node())
-
-      assert [
-               %{label: "derive/2"},
-               %{label: "derive/3"}
-             ] = Intellisense.get_completion_items("der", context, node())
-
-      assert [
-               %{label: "count/1"},
-               %{label: "count/2"}
-             ] = Intellisense.get_completion_items("count/", context, node())
-    end
-
-    test "ignores quoted variables when performing variable completion" do
-      context =
-        eval do
-          quote do
-            var!(my_var_1, Elixir) = 1
-          end
-
-          my_var_2 = 2
-        end
-
-      assert [
-               %{label: "my_var_2"}
-             ] = Intellisense.get_completion_items("my_var", context, node())
-    end
-
-    test "completion inside expression" do
-      context = eval(do: nil)
-
-      assert [
-               %{label: "Enum"},
-               %{label: "Enumerable"}
-             ] = Intellisense.get_completion_items("1 En", context, node())
-
-      assert [
-               %{label: "Enum"},
-               %{label: "Enumerable"}
-             ] = Intellisense.get_completion_items("foo(En", context, node())
-
-      assert [
-               %{label: "Enum"},
-               %{label: "Enumerable"}
-             ] = Intellisense.get_completion_items("Test En", context, node())
-
-      assert [
-               %{label: "Enum"},
-               %{label: "Enumerable"}
-             ] = Intellisense.get_completion_items("foo(x,En", context, node())
-
-      assert [
-               %{label: "Enum"},
-               %{label: "Enumerable"}
-             ] = Intellisense.get_completion_items("[En", context, node())
-
-      assert [
-               %{label: "Enum"},
-               %{label: "Enumerable"}
-             ] = Intellisense.get_completion_items("{En", context, node())
-    end
-
-    test "ampersand completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{label: "Enum"},
-               %{label: "Enumerable"}
-             ] = Intellisense.get_completion_items("&En", context, node())
-
-      assert [
-               %{label: "all?/1"},
-               %{label: "all?/2"}
-             ] = Intellisense.get_completion_items("&Enum.al", context, node())
-
-      assert [
-               %{label: "all?/1"},
-               %{label: "all?/2"}
-             ] = Intellisense.get_completion_items("f = &Enum.al", context, node())
-    end
-
-    test "negation operator completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{label: "is_binary/1"}
-             ] = Intellisense.get_completion_items("!is_bin", context, node())
-    end
-
-    test "pin operator completion" do
-      context =
-        eval do
-          my_variable = 2
-        end
-
-      assert [
-               %{label: "my_variable"}
-             ] = Intellisense.get_completion_items("^my_va", context, node())
-    end
-
-    @tag :tmp_dir
-    test "Elixir completion sublevel", %{tmp_dir: tmp_dir} do
-      context =
-        eval tmp_dir do
-        end
-
-      compile_and_save_bytecode(tmp_dir, ~S'''
-      defmodule Livebook.IntellisenseTest.SublevelTest.LevelA.LevelB do
-      end
-      ''')
-
-      assert [%{label: "LevelA"}] =
-               Intellisense.get_completion_items(
-                 "Livebook.IntellisenseTest.SublevelTest.",
-                 context,
-                 node()
-               )
-    end
-
-    test "complete aliases of Elixir modules" do
-      context =
-        eval do
-          alias List, as: MyList
-        end
-
-      assert [
-               %{label: "MyList"}
-             ] = Intellisense.get_completion_items("MyL", context, node())
-
-      assert [
-               %{label: "to_integer/1"},
-               %{label: "to_integer/2"}
-             ] = Intellisense.get_completion_items("MyList.to_integ", context, node())
-    end
-
-    @tag :erl_docs
-    test "complete aliases of Erlang modules" do
-      context =
-        eval do
-          alias :lists, as: EList
-        end
-
-      assert [
-               %{label: "EList"}
-             ] = Intellisense.get_completion_items("EL", context, node())
-
-      assert [
-               %{label: "map/2"},
-               %{label: "mapfoldl/3"},
-               %{label: "mapfoldr/3"}
-             ] = Intellisense.get_completion_items("EList.map", context, node())
-
-      assert %{
-               label: "max/1",
-               kind: :function,
-               documentation: """
-               Returns the first element of `List` that compares greater than or equal to all
-               other elements of `List`.
-
-               ```
-               :lists.max(List)
-               ```\
-               """,
-               insert_text: "max(${})"
-             } in Intellisense.get_completion_items("EList.", context, node())
-
-      assert [] = Intellisense.get_completion_items("EList.Invalid", context, node())
-    end
-
-    test "completion for functions added when compiled module is reloaded" do
-      context = eval(do: nil)
-
-      {:module, _, bytecode, _} =
-        defmodule Sample do
-          def foo(), do: 0
-        end
-
-      assert [%{label: "foo/0"}] =
-               Intellisense.get_completion_items(
-                 "Livebook.IntellisenseTest.Sample.foo",
-                 context,
-                 node()
-               )
-
-      Code.compiler_options(ignore_module_conflict: true)
-
-      defmodule Sample do
-        def foo(), do: 0
-        def foobar(), do: 0
-      end
-
-      assert [
-               %{label: "foo/0"},
-               %{label: "foobar/0"}
-             ] =
-               Intellisense.get_completion_items(
-                 "Livebook.IntellisenseTest.Sample.foo",
-                 context,
-                 node()
-               )
-    after
-      Code.compiler_options(ignore_module_conflict: false)
-      :code.purge(Sample)
-      :code.delete(Sample)
-    end
-
-    @tag :tmp_dir
-    test "completion for struct names", %{tmp_dir: tmp_dir} do
-      context =
-        eval tmp_dir do
-        end
-
-      compile_and_save_bytecode(tmp_dir, ~S'''
-      defmodule Livebook.IntellisenseTest.MyStruct do
-        defstruct [:my_val]
-      end
-      ''')
-
-      assert [
-               %{label: "MyStruct"}
-             ] =
-               Intellisense.get_completion_items(
-                 "Livebook.IntellisenseTest.MyStr",
-                 context,
-                 node()
-               )
-    end
-
-    @tag :tmp_dir
-    test "completion for struct keys", %{tmp_dir: tmp_dir} do
-      compile_and_save_bytecode(tmp_dir, ~S'''
-      defmodule Livebook.IntellisenseTest.MyStruct do
-        defstruct [:my_val]
-      end
-      ''')
-
-      context =
-        eval tmp_dir do
-          struct = %Livebook.IntellisenseTest.MyStruct{}
-        end
-
-      assert [
-               %{label: "my_val"}
-             ] = Intellisense.get_completion_items("struct.my", context, node())
-    end
-
-    @tag :tmp_dir
-    test "completion for struct keys inside struct", %{tmp_dir: tmp_dir} do
-      context =
-        eval tmp_dir do
-        end
-
-      compile_and_save_bytecode(tmp_dir, ~S'''
-      defmodule Livebook.IntellisenseTest.MyStruct do
-        defstruct [:my_val]
-      end
-      ''')
-
-      assert [
-               %{
-                 label: "my_val",
-                 kind: :field,
-                 documentation: """
-                 `%Livebook.IntellisenseTest.MyStruct{}` struct field.
-
-                 **Default**
-
-                 ```
-                 nil
-                 ```\
-                 """,
-                 insert_text: "my_val: "
-               }
-             ] =
-               Intellisense.get_completion_items(
-                 "%Livebook.IntellisenseTest.MyStruct{my",
-                 context,
-                 node()
-               )
-    end
-
-    @tag :tmp_dir
-    test "completion for struct keys inside struct removes filled keys",
-         %{tmp_dir: tmp_dir} do
-      context =
-        eval tmp_dir do
-        end
-
-      compile_and_save_bytecode(tmp_dir, ~S'''
-      defmodule Livebook.IntellisenseTest.MyStruct do
-        defstruct [:my_val]
-      end
-      ''')
-
-      assert [] =
-               Intellisense.get_completion_items(
-                 "%Livebook.IntellisenseTest.MyStruct{my_val: 123, ",
-                 context,
-                 node()
-               )
-    end
-
-    test "completion for struct keys inside struct ignores `__exception__`" do
-      context = eval(do: nil)
-
-      completions = Intellisense.get_completion_items("%ArgumentError{", context, node())
-
-      refute Enum.find(completions, &match?(%{label: "__exception__"}, &1))
-    end
-
-    @tag :tmp_dir
-    test "completion for struct keys in update syntax", %{tmp_dir: tmp_dir} do
-      context =
-        eval tmp_dir do
-        end
-
-      compile_and_save_bytecode(tmp_dir, ~S'''
-      defmodule Livebook.IntellisenseTest.MyStruct do
-        defstruct [:my_val]
-      end
-      ''')
-
-      assert [
-               %{
-                 label: "my_val",
-                 kind: :field,
-                 documentation: _my_val_doc,
-                 insert_text: "my_val: "
-               }
-             ] =
-               Intellisense.get_completion_items(
-                 "%Livebook.IntellisenseTest.MyStruct{struct | ",
-                 context,
-                 node()
-               )
-
-      assert [
-               %{
-                 label: "my_val",
-                 kind: :field,
-                 documentation: _my_val_doc,
-                 insert_text: "my_val: "
-               }
-             ] =
-               Intellisense.get_completion_items(
-                 "%Livebook.IntellisenseTest.MyStruct{struct | my_v",
-                 context,
-                 node()
-               )
-
-      assert [] =
-               Intellisense.get_completion_items(
-                 "%Livebook.IntellisenseTest.MyStruct{struct | my_val: 123, ",
-                 context,
-                 node()
-               )
-    end
-
-    test "completion for map keys in update syntax" do
-      context =
-        eval do
-          map = %{foo: 1}
-        end
-
-      assert [
-               %{
-                 label: "foo",
-                 kind: :field,
-                 documentation: "(field)",
-                 insert_text: "foo: "
-               }
-             ] = Intellisense.get_completion_items("%{map | ", context, node())
-
-      assert [
-               %{
-                 label: "foo",
-                 kind: :field,
-                 documentation: "(field)",
-                 insert_text: "foo: "
-               }
-             ] = Intellisense.get_completion_items("%{map | fo", context, node())
-
-      assert [] = Intellisense.get_completion_items("%{map | foo: 2, ", context, node())
-    end
-
-    test "ignore invalid Elixir module literals" do
-      context = eval(do: nil)
-
-      defmodule(:"Elixir.Livebook.IntellisenseTest.Unicodé", do: nil)
-
-      assert [] =
-               Intellisense.get_completion_items(
-                 "Livebook.IntellisenseTest.Unicod",
-                 context,
-                 node()
-               )
-    after
-      :code.purge(:"Elixir.Livebook.IntellisenseTest.Unicodé")
-      :code.delete(:"Elixir.Livebook.IntellisenseTest.Unicodé")
-    end
-
-    test "known Elixir module attributes completion" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "moduledoc",
-                 kind: :variable,
-                 documentation: """
-                 Provides documentation for the current module.
-
-                 (module attribute)\
-                 """,
-                 insert_text: "moduledoc"
-               }
-             ] = Intellisense.get_completion_items("@modu", context, node())
-    end
-
-    test "handles calls on module attribute" do
-      context = eval(do: nil)
-      assert [] = Intellisense.get_completion_items("@attr.value", context, node())
-    end
-
-    test "includes language keywords" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "nil",
-                 kind: :keyword,
-                 documentation: "(special atom)",
-                 insert_text: "nil"
-               }
-               | _
-             ] = Intellisense.get_completion_items("nil", context, node())
-    end
-
-    test "includes space instead of parentheses for def* macros" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "defmodule/2",
-                 insert_text: "defmodule "
-               }
-             ] = Intellisense.get_completion_items("defmodu", context, node())
-    end
-
-    test "includes space instead of parentheses for keyword macros" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "import/2",
-                 insert_text: "import "
-               }
-             ] = Intellisense.get_completion_items("impor", context, node())
-    end
-
-    test "includes doesn't include space nor parentheses for macros like __ENV__" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "__ENV__/0",
-                 insert_text: "__ENV__"
-               }
-             ] = Intellisense.get_completion_items("__EN", context, node())
-    end
-
-    test "Elixir bitstring modifiers" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "integer",
-                 kind: :type,
-                 documentation: "(bitstring option)",
-                 insert_text: "integer"
-               }
-             ] = Intellisense.get_completion_items("<<a::intege", context, node())
-
-      assert [
-               %{
-                 label: "size",
-                 kind: :type,
-                 documentation: "(bitstring option)",
-                 insert_text: "size(${})"
-               }
-             ] = Intellisense.get_completion_items("<<a::siz", context, node())
-
-      assert %{
-               label: "integer",
-               kind: :type,
-               documentation: "(bitstring option)",
-               insert_text: "integer"
-             } in Intellisense.get_completion_items("<<a::", context, node())
-    end
-
-    test "completion for aliases in special forms" do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "Range",
-                 kind: :struct,
-                 documentation: """
-                 Returns an inclusive range between dates.
-
-                 (struct)\
-                 """,
-                 insert_text: "Range"
-               }
-             ] = Intellisense.get_completion_items("alias Date.", context, node())
-
-      assert %{
-               label: "Atom",
-               kind: :module,
-               documentation: """
-               Atoms are constants whose values are their own name.
-
-               (module)\
-               """,
-               insert_text: "Atom"
-             } in Intellisense.get_completion_items("alias ", context, node())
-
-      refute Intellisense.get_completion_items("alias ", context, node())
-             |> Enum.any?(&(&1.kind == :function))
-    end
-  end
-
-  describe "get_details/3" do
-    test "returns nil if there are no matches" do
-      context = eval(do: nil)
-
-      assert nil == Intellisense.get_details("Unknown.unknown()", 2, context, node())
-    end
-
-    test "returns subject range" do
-      context = eval(do: nil)
-
-      assert %{range: %{from: 1, to: 18}} =
-               Intellisense.get_details("Integer.to_string(10)", 15, context, node())
-
-      assert %{range: %{from: 1, to: 8}} =
-               Intellisense.get_details("Integer.to_string(10)", 2, context, node())
-    end
-
-    test "does not return duplicate details for functions with default arguments" do
-      context = eval(do: nil)
-
-      assert %{contents: [_]} =
-               Intellisense.get_details("Integer.to_string(10)", 15, context, node())
-    end
-
-    test "returns details only for exactly matching identifiers" do
-      context = eval(do: nil)
-
-      assert nil == Intellisense.get_details("Enum.ma", 6, context, node())
-    end
-
-    test "returns full docs" do
-      context = eval(do: nil)
-
-      assert %{contents: [content]} = Intellisense.get_details("Enum.map", 6, context, node())
-      assert content =~ "## Examples"
-    end
-
-    test "returns deprecated docs" do
-      context = eval(do: nil)
-
-      assert %{contents: [content | _]} =
-               Intellisense.get_details("Enum.chunk", 6, context, node())
-
-      assert content =~ "Use Enum.chunk_every/2 instead"
-    end
-
-    test "returns since docs" do
-      context = eval(do: nil)
-
-      assert %{contents: [content]} = Intellisense.get_details("then", 2, context, node())
-      assert content =~ "Since 1.12.0"
-    end
-
-    @tag :erl_docs
-    test "returns full Erlang docs" do
-      context = eval(do: nil)
-
-      assert %{contents: [file]} = Intellisense.get_details(":file.read()", 2, context, node())
-      assert file =~ "## Performance"
-
-      assert %{contents: [file_read]} =
-               Intellisense.get_details(":file.read()", 8, context, node())
-
-      assert file_read =~ "Typical error reasons:"
-
-      assert %{contents: [crypto]} = Intellisense.get_details(":crypto", 5, context, node())
-      assert crypto =~ "This module provides a set of cryptographic functions."
-    end
-
-    test "properly parses unicode" do
-      context = eval(do: nil)
-
-      assert nil == Intellisense.get_details("msg = '🍵'", 8, context, node())
-    end
-
-    test "handles operators" do
-      context = eval(do: nil)
-
-      assert %{contents: [match_op]} = Intellisense.get_details("x = 1", 3, context, node())
-      assert match_op =~ "Match operator."
-    end
-
-    test "handles local calls" do
-      context = eval(do: nil)
-
-      assert %{contents: [to_string_fn]} =
-               Intellisense.get_details("to_string(1)", 3, context, node())
-
-      assert to_string_fn =~ "Converts the argument to a string"
-    end
-
-    test "returns nil for bitstring modifiers" do
-      context = eval(do: nil)
-
-      assert nil == Intellisense.get_details("<<x :: integer>>", 6, context, node())
-      assert nil == Intellisense.get_details("<<x :: integer>>", 10, context, node())
-    end
-
-    test "includes full module name in the docs" do
-      context = eval(do: nil)
-
-      assert %{contents: [date_range]} =
-               Intellisense.get_details("Date.Range", 8, context, node())
-
-      assert date_range =~ "Date.Range"
-    end
-
-    test "returns module-prepended type signatures" do
-      context = eval(do: nil)
-
-      assert %{contents: [type]} = Intellisense.get_details("Date.t", 6, context, node())
-      assert type =~ "Date.t()"
-    end
-
-    @tag :erl_docs
-    test "returns module-prepended Erlang type signatures" do
-      context = eval(do: nil)
-
-      assert %{contents: [type]} =
-               Intellisense.get_details(":code.load_error_rsn", 8, context, node())
-
-      assert type =~ ":code.load_error_rsn()"
-    end
-
-    test "includes type specs" do
-      context = eval(do: nil)
-
-      assert %{contents: [type]} = Intellisense.get_details("Date.t", 6, context, node())
-      assert type =~ "@type t() :: %Date"
-
-      # opaque types are listed without internal definition
-      assert %{contents: [type]} =
-               Intellisense.get_details("MapSet.internal", 10, context, node())
-
-      assert type =~ "@opaque internal(value)\n"
-    end
-
-    @tag :erl_docs
-    test "includes Erlang type specs" do
-      context = eval(do: nil)
-
-      assert %{contents: [type]} =
-               Intellisense.get_details(":code.load_error_rsn", 8, context, node())
-
-      assert type =~ "@type load_error_rsn() ::"
-    end
-
-    test "returns link to online documentation" do
-      context = eval(do: nil)
-
-      assert %{contents: [content]} = Intellisense.get_details("Integer", 1, context, node())
-      assert content =~ ~r"https://hexdocs.pm/elixir/[^/]+/Integer.html"
-
-      assert %{contents: [content]} =
-               Intellisense.get_details("Integer.to_string(10)", 15, context, node())
-
-      assert content =~ ~r"https://hexdocs.pm/elixir/[^/]+/Integer.html#to_string/2"
-
-      # test elixir types
-      assert %{contents: [content]} =
-               Intellisense.get_details("GenServer.on_start", 12, context, node())
-
-      assert content =~ ~r"https://hexdocs.pm/elixir/[^/]+/GenServer.html#t:on_start/0"
-
-      # test erlang types
-      assert %{contents: [content]} =
-               Intellisense.get_details(":code.load_ret", 7, context, node())
-
-      assert content =~ ~r"https://www.erlang.org/doc/man/code.html#type-load_ret"
-
-      # test erlang modules on hexdocs
-      assert %{contents: [content]} =
-               Intellisense.get_details(":telemetry.span", 13, context, node())
-
-      assert content =~ ~r"https://hexdocs.pm/telemetry/[^/]+/telemetry.html#span/3"
-
-      # test erlang applications
-      assert %{contents: [content]} = Intellisense.get_details(":code", 3, context, node())
-      assert content =~ ~r"https://www.erlang.org/doc/man/code.html"
-
-      assert %{contents: [content]} =
-               Intellisense.get_details(":code.load_binary", 10, context, node())
-
-      assert content =~ ~r"https://www.erlang.org/doc/man/code.html#load_binary-3"
-
-      # test erlang modules
-      assert %{contents: [content]} =
-               Intellisense.get_details(":atomics.new", 11, context, node())
-
-      assert content =~ ~r"https://www.erlang.org/doc/man/atomics.html#new-2"
-
-      assert %{contents: [content]} =
-               Intellisense.get_details(":string.uppercase", 11, context, node())
-
-      assert content =~ ~r"https://www.erlang.org/doc/man/string.html#uppercase-1"
-    end
-
-    @tag :tmp_dir
-    test "includes definition location for runtime modules", %{tmp_dir: tmp_dir} do
-      Code.put_compiler_option(:debug_info, true)
-
-      context =
-        eval tmp_dir do
-          alias Livebook.IntellisenseTest.GoToDefinition
-        end
-
-      code = ~S'''
-      defmodule Livebook.IntellisenseTest.GoToDefinition do
-        @type t :: term()
-        @type foo :: foo(:bar)
-        @type foo(var) :: {var, t()}
-
-        defmacro with_logging(do: block) do
-          quote do
-            require Logger
-            Logger.debug("Running code")
-            result = unquote(block)
-            Logger.debug("Result: #{inspect(result)}")
-            result
-          end
-        end
-
-        @spec hello(var :: term()) :: foo(term())
-        def hello(message) do
-          {:bar, message}
-        end
-      end
-      '''
-
-      file = "#{__ENV__.file}#cell:#{Livebook.Utils.random_short_id()}"
-      compile_and_save_bytecode(tmp_dir, code, file)
-
-      assert %{definition: %{line: 1, file: ^file}} =
-               Intellisense.get_details("GoToDefinition", 14, context, node())
-
-      assert %{definition: %{line: 2, file: ^file}} =
-               Intellisense.get_details("GoToDefinition.t", 16, context, node())
-
-      # Currently we are fetching location of the lowest arity
-      assert %{definition: %{line: 3, file: ^file}} =
-               Intellisense.get_details("GoToDefinition.foo", 18, context, node())
-
-      assert %{definition: %{line: 6, file: ^file}} =
-               Intellisense.get_details("GoToDefinition.with_logging", 20, context, node())
-
-      assert %{definition: %{line: 17, file: ^file}} =
-               Intellisense.get_details("GoToDefinition.hello", 18, context, node())
-    after
-      Code.put_compiler_option(:debug_info, false)
-    end
-  end
-
-  describe "get_signature_items/3" do
-    test "returns nil when outside call" do
-      context = eval(do: nil)
-
-      assert nil == Intellisense.get_signature_items("length()", context, node())
-    end
-
-    test "returns nil if there are no matches" do
-      context = eval(do: nil)
-
-      assert nil == Intellisense.get_signature_items("Unknown.unknown(", context, node())
-      assert nil == Intellisense.get_signature_items("Enum.concat(x, y,", context, node())
-    end
-
-    test "supports remote function calls" do
-      context = eval(do: nil)
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: "map(enumerable, fun)",
-                   arguments: ["enumerable", "fun"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("Enum.map(", context, node())
-    end
-
-    test "supports local function calls" do
-      context = eval(do: nil)
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: "length(list)",
-                   arguments: ["list"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("length(", context, node())
-    end
-
-    test "supports manually imported functions and macros" do
-      context =
-        eval do
-          import Enum
-          import Protocol
-        end
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: "map(enumerable, fun)",
-                   arguments: ["enumerable", "fun"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("map(", context, node())
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: ~S"derive(protocol, module, options \\ [])",
-                   arguments: ["protocol", "module", ~S"options \\ []"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("derive(", context, node())
-    end
-
-    test "supports remote function calls on aliases" do
-      context =
-        eval do
-          alias Enum, as: MyEnum
-        end
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: "map(enumerable, fun)",
-                   arguments: ["enumerable", "fun"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("MyEnum.map(", context, node())
-    end
-
-    test "supports anonymous function calls" do
-      context =
-        eval do
-          add = fn x, y -> x + y end
-        end
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: "add.(arg1, arg2)",
-                   arguments: ["arg1", "arg2"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("add.(", context, node())
-    end
-
-    test "supports captured remote function calls" do
-      context =
-        eval do
-          map = &Enum.map/2
-        end
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: "map(enumerable, fun)",
-                   arguments: ["enumerable", "fun"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("map.(", context, node())
-    end
-
-    @tag :erl_docs
-    test "shows signature with arguments for erlang modules" do
-      context = eval(do: nil)
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: "map(Fun, List1)",
-                   arguments: ["Fun", "List1"]
-                 }
-               ]
-             } = Intellisense.get_signature_items(":lists.map(", context, node())
-    end
-
-    test "shows signature with default argument being an anonymous function" do
-      context = eval(do: nil)
-
-      assert %{
-               active_argument: 3,
-               items: [
-                 %{
-                   signature:
-                     ~S"max_by(enumerable, fun, sorter \\ &>=/2, empty_fallback \\ fn -> raise Enum.EmptyError end)",
-                   arguments: [
-                     "enumerable",
-                     "fun",
-                     ~S"sorter \\ &>=/2",
-                     ~S"empty_fallback \\ fn -> raise Enum.EmptyError end"
-                   ]
-                 }
-               ]
-             } =
-               Intellisense.get_signature_items(
-                 "Enum.max_by([1, 2], &Kernel.-/1, &>=/2, ",
-                 context,
-                 node()
-               )
-    end
-
-    test "returns call active argument" do
-      context = eval(do: nil)
-
-      assert %{active_argument: 0, items: [_item]} =
-               Intellisense.get_signature_items("Enum.map([1, ", context, node())
-
-      assert %{active_argument: 1, items: [_item]} =
-               Intellisense.get_signature_items("Enum.map([1, 2], ", context, node())
-
-      assert %{active_argument: 1, items: [_item]} =
-               Intellisense.get_signature_items(
-                 "Enum.map([1, 2], fn x -> x * x end",
-                 context,
-                 node()
-               )
-
-      assert %{active_argument: 2, items: [_item]} =
-               Intellisense.get_signature_items("IO.ANSI.color(1, 2, 3", context, node())
-
-      assert %{active_argument: 1, items: [_item]} =
-               Intellisense.get_signature_items("elem(x, 1 + ", context, node())
-    end
-
-    test "returns correct active argument when using pipe operator" do
-      context = eval(do: nil)
-
-      assert %{active_argument: 1, items: [_item]} =
-               Intellisense.get_signature_items("[1, 2] |> Enum.map(", context, node())
-
-      assert %{active_argument: 1, items: [_item]} =
-               Intellisense.get_signature_items(
-                 "[1, 2] |> Enum.map(fn x -> x * x end",
-                 context,
-                 node()
-               )
-
-      assert %{active_argument: 2, items: [_item]} =
-               Intellisense.get_signature_items("1 |> IO.ANSI.color(2, 3", context, node())
-    end
-
-    test "returns a single signature for functions with default arguments" do
-      context = eval(do: nil)
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: ~S"to_string(integer, base \\ 10)",
-                   arguments: ["integer", ~S"base \\ 10"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("Integer.to_string(", context, node())
-    end
-
-    test "returns multiple signatures for function with multiple arities" do
-      context = eval(do: nil)
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   signature: "concat(enumerables)",
-                   arguments: ["enumerables"]
-                 },
-                 %{
-                   signature: "concat(left, right)",
-                   arguments: ["left", "right"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("Enum.concat(", context, node())
-    end
-
-    test "returns only signatures where active argument is at valid position" do
-      context = eval(do: nil)
-
-      assert %{
-               active_argument: 1,
-               items: [
-                 %{
-                   signature: "concat(left, right)",
-                   arguments: ["left", "right"]
-                 }
-               ]
-             } = Intellisense.get_signature_items("Enum.concat([1, 2], ", context, node())
-    end
-
-    test "does not return any signatures when in do-end block" do
-      context = eval(do: nil)
-
-      assert nil == Intellisense.get_signature_items("if true do ", context, node())
-    end
-
-    test "does not return any signatures for module attributes" do
-      context = eval(do: nil)
-
-      assert nil == Intellisense.get_signature_items("@length(", context, node())
-    end
-
-    test "does not returns signatures for calls in attribute value" do
-      context = eval(do: nil)
-
-      assert %{
-               active_argument: 0,
-               items: [
-                 %{
-                   arguments: ["list"],
-                   signature: "length(list)"
-                 }
-               ]
-             } = Intellisense.get_signature_items("@attr length(", context, node())
-    end
-  end
-
-  # Remote intellisense tests
-
-  setup_all do
-    # We use the standalone runtime to mimic a remote node. Note that
-    # in the past we used :peer.start, but it was often failing on CI
-    # (the start was timing out)
-
-    pid = Livebook.Runtime.Standalone.new() |> Livebook.Runtime.connect()
-    assert_receive {:runtime_connect_done, ^pid, {:ok, runtime}}
-
-    parent = self()
-
-    runtime_owner_pid =
-      start_supervised!({
-        Task,
-        fn ->
-          Livebook.Runtime.take_ownership(runtime)
-
-          code =
-            ~S'''
-            defmodule RemoteModule do
-              @moduledoc """
-              RemoteModule module docs
-              """
-
-              @doc """
-              Hello doc
-              """
-              def hello(message) do
-                message
-              end
-            end
-            '''
-
-          Livebook.Runtime.evaluate_code(runtime, :elixir, code, {:c1, :e1}, [])
-          receive do: ({:runtime_evaluation_response, :e1, _, _} -> :ok)
-          send(parent, :continue)
-
-          receive do: (:done -> :ok)
-        end
-      })
-
-    receive do: (:continue -> :ok)
-
-    on_exit(fn ->
-      send(runtime_owner_pid, :done)
-    end)
-
-    [node: runtime.node]
-  end
-
-  describe "intellisense completion for remote nodes" do
-    test "do not find the RemoteModule inside the Livebook node" do
-      context = eval(do: nil)
-      assert [] == Intellisense.get_completion_items("RemoteModule", context, node())
-    end
-
-    test "find the RemoteModule and its docs", %{node: node} do
-      context = eval(do: nil)
-
-      assert %{
-               label: "RemoteModule",
-               kind: :module,
-               documentation: """
-               No documentation available
-
-               (module)\
-               """,
-               insert_text: "RemoteModule"
-             } in Intellisense.get_completion_items("RemoteModule", context, node)
-    end
-
-    test "find RemoteModule exported functions and its docs", %{node: node} do
-      context = eval(do: nil)
-
-      assert %{
-               label: "hello/1",
-               kind: :function,
-               documentation: """
-               No documentation available
-
-               ```
-               RemoteModule.hello(arg1)
-               ```\
-               """,
-               insert_text: "hello(${})"
-             } in Intellisense.get_completion_items("RemoteModule.hel", context, node)
-    end
-
-    @tag :erl_docs
-    test "find modules from apps", %{node: node} do
-      context = eval(do: nil)
-
-      assert [
-               %{
-                 label: "unsubscribe/1",
-                 kind: :function,
-                 documentation: """
-                 No documentation available
-
-                 ```
-                 :mnesia.unsubscribe(arg1)
-                 ```\
-                 """,
-                 insert_text: "unsubscribe(${})"
-               }
-             ] = Intellisense.get_completion_items(":mnesia.unsub", context, node)
-    end
-
-    test "get details", %{node: node} do
-      context = eval(do: nil)
-
-      assert %{contents: [content]} = Intellisense.get_details("RemoteModule", 6, context, node)
-      assert content =~ "No documentation available"
-    end
-  end
-
-  defp compile_and_save_bytecode(dir, code, file \\ "nofile") do
-    [{module, bytecode}] = Code.compile_string(code, file)
-    path = Path.join(dir, "#{module}.beam")
-
-    File.write!(path, bytecode)
-    Code.prepend_path(dir)
-
-    on_exit(fn ->
-      Code.delete_path(dir)
-      :code.purge(module)
-      :code.delete(module)
-    end)
-  end
-end
diff --git a/test/livebook/runtime/erl_dist/runtime_server_test.exs b/test/livebook/runtime/erl_dist/runtime_server_test.exs
index 738634875..411b31390 100644
--- a/test/livebook/runtime/erl_dist/runtime_server_test.exs
+++ b/test/livebook/runtime/erl_dist/runtime_server_test.exs
@@ -151,7 +151,7 @@ defmodule Livebook.Runtime.ErlDist.RuntimeServerTest do
   describe "handle_intellisense/6 given completion request" do
     test "provides basic completion when no evaluation reference is given", %{pid: pid} do
       request = {:completion, "System.ver"}
-      ref = RuntimeServer.handle_intellisense(pid, self(), request, [], nil)
+      ref = RuntimeServer.handle_intellisense(pid, self(), :elixir, request, [], nil)
 
       assert_receive {:runtime_intellisense_response, ^ref, ^request,
                       %{items: [%{label: "version/0"}]}}
@@ -169,7 +169,7 @@ defmodule Livebook.Runtime.ErlDist.RuntimeServerTest do
       request = {:completion, "num"}
 
       ref =
-        RuntimeServer.handle_intellisense(pid, self(), request, [{:c1, :e1}], nil)
+        RuntimeServer.handle_intellisense(pid, self(), :elixir, request, [{:c1, :e1}], nil)
 
       assert_receive {:runtime_intellisense_response, ^ref, ^request,
                       %{items: [%{label: "number"}]}}
@@ -177,7 +177,7 @@ defmodule Livebook.Runtime.ErlDist.RuntimeServerTest do
       request = {:completion, "ANSI.brigh"}
 
       ref =
-        RuntimeServer.handle_intellisense(pid, self(), request, [{:c1, :e1}], nil)
+        RuntimeServer.handle_intellisense(pid, self(), :elixir, request, [{:c1, :e1}], nil)
 
       assert_receive {:runtime_intellisense_response, ^ref, ^request,
                       %{items: [%{label: "bright/0"}]}}
@@ -187,7 +187,7 @@ defmodule Livebook.Runtime.ErlDist.RuntimeServerTest do
   describe "handle_intellisense/6 given details request" do
     test "responds with identifier details", %{pid: pid} do
       request = {:details, "System.version", 10}
-      ref = RuntimeServer.handle_intellisense(pid, self(), request, [], nil)
+      ref = RuntimeServer.handle_intellisense(pid, self(), :elixir, request, [], nil)
 
       assert_receive {:runtime_intellisense_response, ^ref, ^request,
                       %{range: %{from: 1, to: 15}, contents: [_]}}
@@ -197,7 +197,7 @@ defmodule Livebook.Runtime.ErlDist.RuntimeServerTest do
   describe "handle_intellisense/6 given format request" do
     test "responds with a formatted code", %{pid: pid} do
       request = {:format, "System.version"}
-      ref = RuntimeServer.handle_intellisense(pid, self(), request, [], nil)
+      ref = RuntimeServer.handle_intellisense(pid, self(), :elixir, request, [], nil)
 
       assert_receive {:runtime_intellisense_response, ^ref, ^request, %{code: "System.version()"}}
     end
diff --git a/test/livebook_web/live/session_live_test.exs b/test/livebook_web/live/session_live_test.exs
index ee4d1c4a7..7a7582fb8 100644
--- a/test/livebook_web/live/session_live_test.exs
+++ b/test/livebook_web/live/session_live_test.exs
@@ -674,7 +674,7 @@ defmodule LivebookWeb.SessionLiveTest do
                Session.get_data(session.pid)
     end
 
-    test "shows an error when a cell langauge is not enabled", %{conn: conn, session: session} do
+    test "shows an error when a cell language is not enabled", %{conn: conn, session: session} do
       section_id = insert_section(session.pid)
       cell_id = insert_text_cell(session.pid, section_id, :code)
 
diff --git a/test/support/noop_runtime.ex b/test/support/noop_runtime.ex
index 05a8df02f..032e3f351 100644
--- a/test/support/noop_runtime.ex
+++ b/test/support/noop_runtime.ex
@@ -28,7 +28,7 @@ defmodule Livebook.Runtime.NoopRuntime do
     def evaluate_code(_, _, _, _, _, _ \\ []), do: :ok
     def forget_evaluation(_, _), do: :ok
     def drop_container(_, _), do: :ok
-    def handle_intellisense(_, _, _, _, _), do: make_ref()
+    def handle_intellisense(_, _, _, _, _, _), do: make_ref()
 
     def read_file(_, path) do
       case File.read(path) do
diff --git a/test/support/test_helpers.ex b/test/support/test_helpers.ex
index 9591d4edb..28ec6b8f7 100644
--- a/test/support/test_helpers.ex
+++ b/test/support/test_helpers.ex
@@ -148,4 +148,21 @@ defmodule Livebook.TestHelpers do
   defp remove_ansi(string) do
     String.replace(string, ~r/\e\[\d+m/, "")
   end
+
+  # Returns intellisense context resulting from evaluating
+  # the given block of code in a fresh context.
+  defmacro intellisense_context_from_eval(ebin_path \\ System.tmp_dir!(), do: block) do
+    quote do
+      block = unquote(Macro.escape(block))
+      binding = []
+      env = Code.env_for_eval([])
+      {value, binding, env} = Code.eval_quoted_with_env(block, binding, env)
+
+      %{
+        env: env,
+        ebin_path: unquote(ebin_path),
+        map_binding: fn fun -> fun.(binding) end
+      }
+    end
+  end
 end