fix: address PR review comments (binary unit widths, hint cache key, doc types)

- type_inference: honor `unit` when deciding sub-byte binary segments — the
  effective bit width is size * unit, so <<1::size(1)-unit(8)>> is a
  byte-aligned binary, not a bitstring. Also handles the 2*4 size*unit
  shorthand. Regression tests added.
- type_hints: include (sorted) render opts in the type_hint_at cache key so a
  call with e.g. max_length does not poison later calls expecting the default
  rendering. Regression test added.
- type_presentation_test: async: false — it mutates the global
  :use_elixir_types app env and could race concurrent modules.
- hover docs: variable/attribute/keyword doc typespecs said name: atom() but
  builders produce strings; keyword_doc kind corrected :attribute -> :keyword.
- completion_engine: comment no longer claims rendered type forms are always
  parseable (open-map markers are not; nil fallback is intentional).

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

Author: lukaszsamson

lib/elixir_sense/core/type_hints.ex

@@ -249,7 +249,10 @@ defmodule ElixirSense.Core.TypeHints do
           :skip | {:ok, hint}
   def type_hint_at(%Context{} = ctx, position, var_name, opts \\ [])
       when is_atom(var_name) do
-    cached({__MODULE__, ctx.ref, :hint_at, position, var_name}, fn ->
+    # `opts` affect rendering (e.g. max_length, widen_literals), so they must
+    # be part of the key — otherwise the first caller's formatting poisons
+    # later calls with different options.
+    cached({__MODULE__, ctx.ref, :hint_at, position, var_name, Enum.sort(opts)}, fn ->
       compute_hint_at(ctx, position, var_name, opts)
     end)
   end

lib/elixir_sense/core/type_inference.ex

@@ -727,22 +727,47 @@ defmodule ElixirSense.Core.TypeInference do
     cond do
       Enum.any?(parts, &(&1 in [:binary, :bytes, :utf8, :utf16, :utf32, :float])) -> false
       Enum.any?(parts, &(&1 in [:bitstring, :bits])) -> true
-      true -> Enum.any?(parts, &(is_integer(&1) and rem(&1, 8) != 0))
+      true -> sub_byte_width?(parts)
     end
   end
 
   # A segment without `::` is the default (integer, 8 bits — byte-aligned).
   defp sub_byte_segment?(_other), do: false
 
+  # The effective bit width is size * unit (unit defaults to 1 for integer
+  # segments), so `<<1::size(1)-unit(8)>>` is a byte-aligned 8-bit segment,
+  # not a sub-byte one. Non-literal sizes yield no `{:size, _}` entry and stay
+  # conservative (not sub-byte).
+  defp sub_byte_width?(parts) do
+    size =
+      Enum.find_value(parts, fn
+        {:size, n} -> n
+        _other -> nil
+      end)
+
+    unit =
+      Enum.find_value(parts, fn
+        {:unit, n} -> n
+        _other -> nil
+      end) || 1
+
+    is_integer(size) and rem(size * unit, 8) != 0
+  end
+
   defp flatten_segment_spec({:-, _, [left, right]}),
     do: flatten_segment_spec(left) ++ flatten_segment_spec(right)
 
+  # `size*unit` shorthand (`<<x::2*4>>` is size 2, unit 4).
+  defp flatten_segment_spec({:*, _, [size, unit]}) when is_integer(size) and is_integer(unit),
+    do: [{:size, size}, {:unit, unit}]
+
   defp flatten_segment_spec({:*, _, [left, right]}),
     do: flatten_segment_spec(left) ++ flatten_segment_spec(right)
 
-  defp flatten_segment_spec({:size, _, [n]}) when is_integer(n), do: [n]
+  defp flatten_segment_spec({:size, _, [n]}) when is_integer(n), do: [{:size, n}]
+  defp flatten_segment_spec({:unit, _, [n]}) when is_integer(n), do: [{:unit, n}]
   defp flatten_segment_spec({name, _, _}) when is_atom(name), do: [name]
-  defp flatten_segment_spec(n) when is_integer(n), do: [n]
+  defp flatten_segment_spec(n) when is_integer(n), do: [{:size, n}]
   defp flatten_segment_spec(_other), do: []
 
   # The result type of a `for` from its (last-clause) opts. `:reduce` wins over

lib/elixir_sense/providers/completion/completion_engine.ex

@@ -1400,7 +1400,8 @@ defmodule ElixirSense.Providers.Completion.CompletionEngine do
 
   # `type_spec` here is a quoted type AST (to_entries renders it with
   # Macro.to_string). TypePresentation renders to text, so parse it back to an
-  # AST; the rendered forms are always valid type expressions.
+  # AST — best-effort: some rendered forms (e.g. open-map `...` markers) are
+  # not parseable, in which case we fall back to nil.
   defp rendered_field_type(value) do
     with {:ok, text} <- TypePresentation.render(value),
          {:ok, ast} <- Code.string_to_quoted(text) do

lib/elixir_sense/providers/hover/docs.ex

@@ -44,21 +44,21 @@ defmodule ElixirSense.Providers.Hover.Docs do
         }
 
   @type variable_doc :: %{
-          name: atom(),
+          name: String.t(),
           kind: :variable,
           # Rendered inferred type (best-effort), or nil when nothing useful.
           type: String.t() | nil
         }
 
   @type attribute_doc :: %{
-          name: atom(),
+          name: String.t(),
           kind: :attribute,
           docs: markdown()
         }
 
   @type keyword_doc :: %{
-          name: atom(),
-          kind: :attribute,
+          name: String.t(),
+          kind: :keyword,
           docs: markdown()
         }
 

test/elixir_sense/core/type_hints_test.exs

@@ -514,24 +514,38 @@ defmodule ElixirSense.Core.TypeHintsTest do
              "Flow-sensitivity not observable: both positions returned #{inspect(result_narrow)}"
     end
 
-    test "result is cached per {ref, :hint_at, position, var_name}" do
+    test "result is cached per {ref, :hint_at, position, var_name, opts}" do
       md = metadata(@flow_code, {5, 9})
       pos = {5, 9}
       ctx = TypeHints.request_context(md)
-      cache_key = {TypeHints, ctx.ref, :hint_at, pos, :x}
+      cache_key = {TypeHints, ctx.ref, :hint_at, pos, :x, []}
 
       assert Process.get(cache_key) == nil
       result = TypeHints.type_hint_at(ctx, pos, :x, [])
       assert Process.get(cache_key) == result
     end
 
+    test "different render opts do not poison each other's cache entries" do
+      md = metadata(@flow_code, {5, 9})
+      pos = {5, 9}
+      ctx = TypeHints.request_context(md)
+
+      {:ok, default_hint} = TypeHints.type_hint_at(ctx, pos, :x, [])
+      {:ok, truncated_hint} = TypeHints.type_hint_at(ctx, pos, :x, max_length: 3)
+
+      # The truncated call must not return the earlier default rendering...
+      assert truncated_hint.label != default_hint.label
+      # ...and the default entry must survive the truncated call unchanged.
+      assert {:ok, ^default_hint} = TypeHints.type_hint_at(ctx, pos, :x, [])
+    end
+
     test "discard/1 also erases hint_at cache entries" do
       md = metadata(@flow_code, {5, 9})
       pos = {5, 9}
       ctx = TypeHints.request_context(md)
 
       TypeHints.type_hint_at(ctx, pos, :x, [])
-      cache_key = {TypeHints, ctx.ref, :hint_at, pos, :x}
+      cache_key = {TypeHints, ctx.ref, :hint_at, pos, :x, []}
       assert Process.get(cache_key) != nil
 
       TypeHints.discard(ctx)

test/elixir_sense/core/type_inference_test.exs

@@ -709,6 +709,18 @@ defmodule ElixirSense.Core.TypeInferenceTest do
       assert type_of("<<x::binary-size(4)>>") == {:binary, nil}
       assert type_of("<<x::utf8>>") == {:binary, nil}
     end
+
+    test "bitstring vs binary: unit multiplies size for effective bit width" do
+      # size(1)-unit(8) is 8 bits — byte-aligned binary, not a bitstring
+      assert type_of("<<1::size(1)-unit(8)>>") == {:binary, nil}
+      assert type_of("<<x::integer-size(2)-unit(8)>>") == {:binary, nil}
+      # 2*4 shorthand (size 2, unit 4) is 8 bits — binary
+      assert type_of("<<1::2*4>>") == {:binary, nil}
+      # size(3)-unit(2) is 6 bits — sub-byte
+      assert type_of("<<1::size(3)-unit(2)>>") == :bitstring
+      # unit without a literal size stays conservative (binary)
+      assert type_of("<<x::size(n)-unit(8)>>") == {:binary, nil}
+    end
   end
 
   describe "special forms" do

test/elixir_sense/core/type_presentation_test.exs

@@ -1,5 +1,7 @@
 defmodule ElixirSense.Core.TypePresentationTest do
-  use ExUnit.Case, async: true
+  # async: false — some tests mutate the global :use_elixir_types app env,
+  # which would race with concurrently-running modules that read the flag.
+  use ExUnit.Case, async: false
 
   alias ElixirSense.Core.Binding
   alias ElixirSense.Core.State.VarInfo