Handle new cursor context from Elixir 1.19+

Author: aleDsz

lib/livebook/intellisense/elixir.ex

@@ -228,6 +228,22 @@ defmodule Livebook.Intellisense.Elixir do
     }
   end
 
+  defp format_completion_item(%{kind: :keyword, name: name}),
+    do: %{
+      label: Atom.to_string(name),
+      kind: :keyword,
+      documentation: "(keyword)",
+      insert_text: Atom.to_string(name)
+    }
+
+  defp format_completion_item(%{kind: :binary_operator, name: name, arity: arity}),
+    do: %{
+      label: "#{name}/#{arity}",
+      kind: :binary_operator,
+      documentation: "(binary operator)",
+      insert_text: Atom.to_string(name)
+    }
+
   defp keyword_macro?(name) do
     def? = name |> Atom.to_string() |> String.starts_with?("def")
 
@@ -306,7 +322,8 @@ defmodule Livebook.Intellisense.Elixir do
     :interface,
     :function,
     :type,
-    :bitstring_option
+    :bitstring_option,
+    :binary_operator
   ]
 
   defp completion_item_priority(%{kind: :struct} = completion_item) do
@@ -419,6 +436,8 @@ defmodule Livebook.Intellisense.Elixir do
     ])
   end
 
+  defp format_details_item(%{kind: :keyword, name: name}), do: code(name)
+
   defp get_definition_location(%{kind: :module, module: module}, context) do
     get_definition_location(module, context, {:module, module})
   end

lib/livebook/intellisense/elixir/identifier_matcher.ex

@@ -72,6 +72,8 @@ defmodule Livebook.Intellisense.Elixir.IdentifierMatcher do
               name: name(),
               arity: integer()
             }
+          | %{kind: :keyword, name: name()}
+          | %{kind: :binary_operator, name: name(), arity: arity()}
 
   @type name :: atom()
   @type display_name :: String.t()
@@ -99,6 +101,26 @@ defmodule Livebook.Intellisense.Elixir.IdentifierMatcher do
   @alias_only_atoms ~w(alias import require)a
   @alias_only_charlists ~w(alias import require)c
 
+  @block_keywords ~w(do end after catch else rescue)
+
+  @kernel_operators ["**", "*", "/", "+", "-", "++", "--", "..", "<>"] ++
+                      ["in", "|>", "<", ">", "<=", ">=", "==", "!=", "=~", "===", "!=="] ++
+                      ["&&", "and", "||", "or", "="]
+
+  @bitwise_operators ["<<<", ">>>", "&&&", "|||"]
+
+  @special_forms_operators ["::", "="]
+
+  @binary_operators ["+++", "---", "not in", "<<~", "~>>", "<~", "~>", "<~>"] ++
+                      ["=>", "|", "when", "<-", "\\\\"]
+
+  @binary_operators_docs [
+    {Kernel, @kernel_operators},
+    {Kernel.SpecialForms, @special_forms_operators},
+    {Bitwise, @bitwise_operators},
+    {nil, @binary_operators}
+  ]
+
   @doc """
   Clears all loaded entries stored for node.
   """
@@ -247,6 +269,9 @@ defmodule Livebook.Intellisense.Elixir.IdentifierMatcher do
       {:struct, struct} ->
         match_struct(List.to_string(struct), ctx)
 
+      {:block_keyword_or_binary_operator, hint} ->
+        match_block_keyword_or_binary_operator(List.to_string(hint), ctx)
+
       # :none
       _ ->
         []
@@ -351,6 +376,35 @@ defmodule Livebook.Intellisense.Elixir.IdentifierMatcher do
         do: item
   end
 
+  defp match_block_keyword_or_binary_operator(hint, ctx) do
+    block_keywords =
+      for value <- match_values_from_hint(hint, @block_keywords, ctx) do
+        %{kind: :keyword, name: value}
+      end
+
+    binary_operators =
+      for {mod, values} <- @binary_operators_docs,
+          name <- match_values_from_hint(hint, values, ctx) do
+        if mod do
+          match_module_function(mod, hint, ctx)
+        else
+          %{kind: :binary_operator, name: name, arity: 2}
+        end
+      end
+
+    result = List.flatten(block_keywords ++ binary_operators)
+
+    if result != [] do
+      result
+    end
+  end
+
+  defp match_values_from_hint(hint, values, ctx) do
+    for value <- values, ctx.matcher.(value, hint) do
+      String.to_existing_atom(value)
+    end
+  end
+
   defp has_struct?(mod) do
     Code.ensure_loaded?(mod) and function_exported?(mod, :__struct__, 1)
   end
@@ -690,34 +744,33 @@ defmodule Livebook.Intellisense.Elixir.IdentifierMatcher do
         )
 
       Enum.map(matching_funs, fn {name, arity, type} ->
-        doc_item =
-          Enum.find(
-            doc_items,
-            %{from_default: false, documentation: nil, signatures: [], specs: [], meta: %{}},
-            fn doc_item ->
-              doc_item.name == name && doc_item.arity == arity
-            end
-          )
-
-        %{
-          kind: :function,
-          module: mod,
-          name: name,
-          arity: arity,
-          type: type,
-          display_name: Atom.to_string(name),
-          from_default: doc_item.from_default,
-          documentation: doc_item.documentation,
-          signatures: doc_item.signatures,
-          specs: doc_item.specs,
-          meta: doc_item.meta
-        }
+        function_with_docs(mod, doc_items, name, arity, type)
       end)
     else
       []
     end
   end
 
+  defp function_with_docs(mod, doc_items, name, arity, type) do
+    item = %{
+      kind: :function,
+      module: mod,
+      name: name,
+      arity: arity,
+      type: type,
+      display_name: Atom.to_string(name)
+    }
+
+    doc_item =
+      if doc_item = Enum.find(doc_items, &(&1.name == name and &1.arity == arity)) do
+        Map.take(doc_item, [:documentation, :from_default, :meta, :signatures, :specs])
+      else
+        %{from_default: false, documentation: nil, signatures: [], specs: [], meta: %{}}
+      end
+
+    Map.merge(item, doc_item)
+  end
+
   defp exports(mod, node) do
     try do
       :erpc.call(node, mod, :module_info, [:exports])

mix.exs

@@ -5,7 +5,7 @@ end
 defmodule Livebook.MixProject do
   use Mix.Project
 
-  @elixir_requirement "~> 1.18"
+  @elixir_requirement "~> 1.20"
   @version "0.20.0-dev"
   @description "Automate code & data workflows with interactive notebooks"
 

test/livebook/intellisense/elixir_test.exs

@@ -1685,6 +1685,42 @@ defmodule Livebook.Intellisense.ElixirTest do
 
       refute Enum.any?(items, &(&1.kind == :function))
     end
+
+    test "completion for block keywords and binary operators" do
+      context = intellisense_context_from_eval(do: nil)
+
+      assert %{
+               items: [
+                 %{documentation: "(keyword)", insert_text: "do", kind: :keyword, label: "do"}
+               ]
+             } = Intellisense.Elixir.handle_request({:completion, "if true d"}, context, node())
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "if 1 "}, context, node())
+
+      assert %{
+               documentation: "(binary operator)",
+               insert_text: "\\\\",
+               kind: :binary_operator,
+               label: "\\\\/2"
+             } in items
+
+      assert %{items: items} =
+               Intellisense.Elixir.handle_request({:completion, "if 1 +"}, context, node())
+
+      assert %{
+               documentation: """
+               Arithmetic addition operator.
+
+               ```
+               left + right
+               ```\
+               """,
+               insert_text: "+",
+               kind: :function,
+               label: "+/2"
+             } in items
+    end
   end
 
   describe "details" do

versions

@@ -3,7 +3,7 @@
 # across three versions. So, for example, if Rebar3 is compiled for 26,
 # then the executable will be good for 26..28. You can find the executable
 # version in Rebar3 CI files.
-elixir="1.19.3"
+elixir="1.20.1"
 otp="28.1.1"
 rebar3="3.24.0"
 ubuntu="noble-20251013"