completion: restore state-based bitstring modifier filtering; bump elixir_sense

Mirror the elixir_sense fix in the ElixirLS.Utils.CompletionEngine copy: the
`:bitstring_modifier` branch now parses the modifiers already typed after `::`
into a state and keeps only the modifiers that may still legally follow (type /
sign / endianness / utf / size / unit rules), instead of only dropping names
already present. Fixes invalid suggestions like `signed`/`little` after
`binary-`, `size`/`unit` after `utf8-`, `signed`/`binary` after `float-`.

Assert the invalid options are absent (not just valid ones present) in both
elixir_ls_utils (complete_test) and language_server (suggestions_test) suites.

Bump elixir_sense to 89eda3fc (same fix in the shared engine).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XRd15BX6wBpZ8ThaNSo232

Author: lukaszsamson

apps/elixir_ls_utils/lib/completion_engine.ex

@@ -97,6 +97,25 @@ defmodule ElixirLS.Utils.CompletionEngine do
     %{type: :bitstring_option, name: "utf32"}
   ]
 
+  # Bitstring modifier validity rules (UTS of `<<x::type-sign-endianness-size-unit>>`). Used to keep
+  # `:bitstring_modifier` completion from offering combinations Elixir rejects (e.g. `signed` after
+  # `binary-`, `size`/`unit` after `utf8-`). Inlined here rather than pulled from a separate module so
+  # the completion engine stays self-contained.
+  @bitstring_types [:integer, :float, :bitstring, :binary, :utf8, :utf16, :utf32]
+  @bitstring_utf_types [:utf8, :utf16, :utf32]
+  @bitstring_type_aliases [bits: :bitstring, bytes: :binary]
+  @bitstring_sign_modifiers [:signed, :unsigned]
+  @bitstring_endianness_modifiers [:little, :big, :native]
+  # types each endianness modifier is compatible with, when the type is not yet fixed
+  @bitstring_endianness_types [:integer, :float, :utf16, :utf32]
+  @bitstring_default_state %{
+    type: nil,
+    sign_modifier: nil,
+    endianness_modifier: nil,
+    size: nil,
+    unit: nil
+  }
+
   @alias_only_atoms ~w(alias import require)a
   @alias_only_charlists ~w(alias import require)c
 
@@ -796,16 +815,22 @@ defmodule ElixirLS.Utils.CompletionEngine do
         {container_context_map_fields(pairs, {:struct, alias}, map, hint, metadata), continue?}
 
       :bitstring_modifier ->
-        existing =
+        # Parse the modifiers already typed after `::` into a state and keep only the modifiers that
+        # may still legally follow (honoring the type / sign / endianness / utf / size / unit rules),
+        # instead of merely excluding names already present - which would offer invalid combinations
+        # such as `signed`/`little` after `binary-`, or `size`/`unit`/`signed` after `utf8-`.
+        available_names =
           code
           |> List.to_string()
           |> String.split("::")
           |> List.last()
-          |> String.split("-")
+          |> bitstring_parse()
+          |> bitstring_available_options()
+          |> Enum.map(&Atom.to_string/1)
 
         results =
           @bitstring_modifiers
-          |> Enum.filter(&(Matcher.match?(&1.name, hint) and &1.name not in existing))
+          |> Enum.filter(&(&1.name in available_names and Matcher.match?(&1.name, hint)))
           |> format_expansion()
 
         {results, false}
@@ -815,6 +840,92 @@ defmodule ElixirLS.Utils.CompletionEngine do
     end
   end
 
+  # Parse the modifier text already typed after `::` (e.g. `binary-siz`) into a
+  # `%{type, sign_modifier, endianness_modifier, size, unit}` state. Unknown/partial characters (the
+  # in-progress hint) are skipped one at a time, so a complete parse is not required.
+  defp bitstring_parse(text), do: bitstring_parse(text, @bitstring_default_state)
+
+  for type <- @bitstring_types do
+    defp bitstring_parse(<<unquote(Atom.to_string(type)), rest::binary>>, acc),
+      do: bitstring_parse(rest, %{acc | type: unquote(type)})
+  end
+
+  for {type_alias, type} <- @bitstring_type_aliases do
+    defp bitstring_parse(<<unquote(Atom.to_string(type_alias)), rest::binary>>, acc),
+      do: bitstring_parse(rest, %{acc | type: unquote(type)})
+  end
+
+  for sign <- @bitstring_sign_modifiers do
+    defp bitstring_parse(<<unquote(Atom.to_string(sign)), rest::binary>>, acc),
+      do: bitstring_parse(rest, %{acc | sign_modifier: unquote(sign)})
+  end
+
+  for endianness <- @bitstring_endianness_modifiers do
+    defp bitstring_parse(<<unquote(Atom.to_string(endianness)), rest::binary>>, acc),
+      do: bitstring_parse(rest, %{acc | endianness_modifier: unquote(endianness)})
+  end
+
+  defp bitstring_parse(<<"-", rest::binary>>, acc), do: bitstring_parse(rest, acc)
+
+  defp bitstring_parse(<<"size", rest::binary>>, acc),
+    do: bitstring_parse(rest, %{acc | size: true})
+
+  defp bitstring_parse(<<"unit", rest::binary>>, acc),
+    do: bitstring_parse(rest, %{acc | unit: true})
+
+  defp bitstring_parse(<<_::binary-size(1), rest::binary>>, acc), do: bitstring_parse(rest, acc)
+  defp bitstring_parse(<<>>, acc), do: acc
+
+  # The modifiers that may still legally follow, given the parsed state.
+  defp bitstring_available_options(state) do
+    bitstring_available_types(state) ++
+      bitstring_available_sign_modifiers(state) ++
+      bitstring_available_endianness_modifiers(state) ++
+      bitstring_available_size(state) ++
+      bitstring_available_unit(state)
+  end
+
+  defp bitstring_available_types(
+         %{type: nil, sign_modifier: nil, endianness_modifier: nil} = state
+       ),
+       do: bitstring_filter_utf(state, @bitstring_types)
+
+  defp bitstring_available_types(%{type: nil, sign_modifier: nil, endianness_modifier: e} = state)
+       when not is_nil(e),
+       do: bitstring_filter_utf(state, @bitstring_endianness_types)
+
+  defp bitstring_available_types(%{type: nil}), do: [:integer]
+  defp bitstring_available_types(_), do: []
+
+  defp bitstring_available_sign_modifiers(%{type: type, sign_modifier: nil})
+       when type in [nil, :integer],
+       do: @bitstring_sign_modifiers
+
+  defp bitstring_available_sign_modifiers(_), do: []
+
+  defp bitstring_available_endianness_modifiers(%{type: type, endianness_modifier: nil})
+       when type in [nil, :integer, :utf16, :utf32],
+       do: @bitstring_endianness_modifiers
+
+  defp bitstring_available_endianness_modifiers(%{type: :float, endianness_modifier: nil}),
+    do: [:little, :big]
+
+  defp bitstring_available_endianness_modifiers(_), do: []
+
+  # size and unit are unsupported on utf types (they fail to compile).
+  defp bitstring_available_size(%{size: nil, type: type}) when type not in @bitstring_utf_types,
+    do: [:size]
+
+  defp bitstring_available_size(_), do: []
+
+  defp bitstring_available_unit(%{unit: nil, type: type}) when type not in @bitstring_utf_types,
+    do: [:unit]
+
+  defp bitstring_available_unit(_), do: []
+
+  defp bitstring_filter_utf(%{size: nil, unit: nil}, list), do: list
+  defp bitstring_filter_utf(_, list), do: list -- @bitstring_utf_types
+
   defp container_context_map_fields(pairs, kind, map, hint, metadata) do
     {keys, types, alias, doc, meta} =
       case kind do

apps/elixir_ls_utils/test/complete_test.exs

@@ -2033,6 +2033,32 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
     refute Enum.any?(entries, &(&1.name == "integer"))
     refute Enum.any?(entries, &(&1.name == "little"))
     assert Enum.any?(entries, &(&1.name == "size" and &1.arity == 1))
+
+    # state-based validity: a `binary` type only allows size/unit to follow
+    names = fn code ->
+      expand(code) |> Enum.filter(&(&1[:type] == :bitstring_option)) |> Enum.map(& &1.name)
+    end
+
+    binary = names.('<<foo::binary-')
+    assert "size" in binary
+    assert "unit" in binary
+    refute "signed" in binary
+    refute "little" in binary
+    refute "native" in binary
+    refute "utf8" in binary
+
+    # utf types take no further modifiers
+    assert names.('<<foo::utf8-') == []
+
+    # float allows little/big (not native), size and unit - but not sign or another type
+    float = names.('<<foo::float-')
+    assert "little" in float
+    assert "big" in float
+    assert "size" in float
+    assert "unit" in float
+    refute "native" in float
+    refute "signed" in float
+    refute "binary" in float
   end
 
   test "completion for aliases in special forms" do

apps/language_server/test/providers/completion/suggestions_test.exs

@@ -4765,6 +4765,53 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.SuggestionTest do
 
     assert "unit" in options
     assert "size" in options
+    # invalid after a `binary` type: sign / endianness / another type must not be offered
+    refute "signed" in options
+    refute "unsigned" in options
+    refute "little" in options
+    refute "big" in options
+    refute "native" in options
+    refute "utf8" in options
+    refute "binary" in options
+
+    # utf types take no further modifiers - size/unit/sign/endianness are all invalid
+    buffer = """
+    defmodule ElixirSenseExample.OtherModule do
+      alias ElixirSenseExample.SameModule
+      def some_fun() do
+        <<abc::integer, asd::utf8->>
+      end
+    end
+    """
+
+    assert [] =
+             Suggestion.suggestions(buffer, 4, 31)
+             |> Enum.filter(&(&1.type == :bitstring_option))
+             |> Enum.map(& &1.name)
+
+    # float supports little/big (not native), size and unit - but not sign or another type
+    buffer = """
+    defmodule ElixirSenseExample.OtherModule do
+      alias ElixirSenseExample.SameModule
+      def some_fun() do
+        <<abc::integer, asd::float->>
+      end
+    end
+    """
+
+    options =
+      Suggestion.suggestions(buffer, 4, 32)
+      |> Enum.filter(&(&1.type == :bitstring_option))
+      |> Enum.map(& &1.name)
+
+    assert "little" in options
+    assert "big" in options
+    assert "size" in options
+    assert "unit" in options
+    refute "native" in options
+    refute "signed" in options
+    refute "binary" in options
+    refute "utf8" in options
 
     buffer = """
     defmodule ElixirSenseExample.OtherModule do

dep_versions.exs

@@ -1,5 +1,5 @@
 [
-  elixir_sense: "99570b9b749dbdde5120e22963c95298365511a0",
+  elixir_sense: "89eda3fc4df9cea0d70c528f3e7e240a70c860f8",
   dialyxir_vendored: "accfec9393079abc4a82b7e79a4997f59f085b67",
   jason_v: "f1c10fa9c445cb9f300266122ef18671054b2330",
   erl2ex_vendored: "04f93e55f46d35d0aa3c149616f2c7a6a1ad9311",

mix.lock

@@ -2,7 +2,7 @@
   "benchee": {:hex, :benchee, "1.1.0", "f3a43817209a92a1fade36ef36b86e1052627fd8934a8b937ac9ab3a76c43062", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.0", [hex: :statistex, repo: "hexpm", optional: false]}], "hexpm", "7da57d545003165a012b587077f6ba90b89210fd88074ce3c60ce239eb5e6d93"},
   "deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
   "dialyxir_vendored": {:git, "https://github.com/elixir-lsp/dialyxir.git", "accfec9393079abc4a82b7e79a4997f59f085b67", [ref: "accfec9393079abc4a82b7e79a4997f59f085b67"]},
-  "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "99570b9b749dbdde5120e22963c95298365511a0", [ref: "99570b9b749dbdde5120e22963c95298365511a0"]},
+  "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "89eda3fc4df9cea0d70c528f3e7e240a70c860f8", [ref: "89eda3fc4df9cea0d70c528f3e7e240a70c860f8"]},
   "erl2ex_vendored": {:git, "https://github.com/elixir-lsp/erl2ex.git", "04f93e55f46d35d0aa3c149616f2c7a6a1ad9311", [ref: "04f93e55f46d35d0aa3c149616f2c7a6a1ad9311"]},
   "erlex_vendored": {:git, "https://github.com/elixir-lsp/erlex.git", "50b8307f90451a5d0288fb239fb6405b5ca1f1a4", [ref: "50b8307f90451a5d0288fb239fb6405b5ca1f1a4"]},
   "jason_v": {:git, "https://github.com/elixir-lsp/jason.git", "f1c10fa9c445cb9f300266122ef18671054b2330", [ref: "f1c10fa9c445cb9f300266122ef18671054b2330"]},