fix(engine): improve entity resolution for HEEx components with curly braces

Previous implementation had a bug where if there was a curly braces
expression on the line with a HEEx component, its arity was always
taken, even if the cursor was on the component. This lead to incorrect
resolution (usually to not be able to resolve the component call).

Author: katafrakt

apps/engine/lib/engine/code_intelligence/heex.ex

@@ -45,14 +45,17 @@ defmodule Engine.CodeIntelligence.Heex do
   def arity({:sigil_H, meta, [{:<<>>, _, parts}, _]}, position, arity_at_position) do
     content = sigil_content(parts)
     sigil_start_line = Keyword.get(meta, :line, 1)
+    sigil_start_column = Keyword.get(meta, :column, 1)
     relative_line = position.line - sigil_start_line
+    # calculate relative column (only meaningful when on first line of sigil content)
+    relative_column = position.character - sigil_start_column
 
     with {:ok, tokens} <- EEx.tokenize(content),
-         {:ok, expr} <- find_expr_at(tokens, relative_line),
+         {:ok, expr} <- find_expr_at(tokens, relative_line, relative_column),
          {:ok, ast} <- Code.string_to_quoted(List.to_string(expr)) do
       arity_at_position.([ast], position)
     else
-      # Component shorthand like `<.button>` - after normalization has arity 1
+      # component shorthand like `<.button>` - after normalization has arity 1
       :component_shorthand -> 1
       _ -> 0
     end
@@ -202,33 +205,64 @@ defmodule Engine.CodeIntelligence.Heex do
     end)
   end
 
-  defp find_expr_at(tokens, target_line) do
+  defp find_expr_at(tokens, target_line, target_column) do
     Enum.find_value(tokens, :component_shorthand, fn
-      {:expr, _marker, expr, %{line: line}} when line == target_line ->
-        {:ok, expr}
+      {:expr, _marker, expr, %{line: line, column: col}} when line == target_line ->
+        # check if cursor is within this expression's column range
+        expr_length = length(expr)
 
-      {:text, text, %{line: start_line}} ->
+        if target_column >= col and target_column <= col + expr_length do
+          {:ok, expr}
+        else
+          nil
+        end
+
+      {:text, text, %{line: start_line, column: start_col}} ->
         text_str = List.to_string(text)
         line_in_text = target_line - start_line
-        find_curly_expr_at_line(text_str, line_in_text)
+        # calculate column offset within the text
+        text_column = if line_in_text == 0, do: target_column - start_col, else: target_column
+        find_curly_expr_at_line(text_str, line_in_text, text_column)
 
       _ ->
         nil
     end)
   end
 
-  defp find_curly_expr_at_line(text, line_offset) do
+  defp find_curly_expr_at_line(text, line_offset, cursor_column) do
     lines = String.split(text, "\n")
 
     if line_offset >= 0 and line_offset < length(lines) do
       line = Enum.at(lines, line_offset)
 
-      case Regex.run(~r/\{([^{}]+)\}/, line) do
-        [_, expr] -> {:ok, String.to_charlist(expr)}
-        _ -> nil
+      # check if cursor on a component shorthand
+      if cursor_on_component_shorthand?(line, cursor_column) do
+        :component_shorthand
+      else
+        # check if cursor inside a curly expression
+        find_curly_expr_at_column(line, cursor_column)
       end
     else
       nil
     end
   end
+
+  defp cursor_on_component_shorthand?(line, cursor_column) do
+    Regex.scan(@component_regex, line, return: :index)
+    |> Enum.any?(fn [{match_start, match_len} | _] ->
+      cursor_column >= match_start and cursor_column < match_start + match_len
+    end)
+  end
+
+  defp find_curly_expr_at_column(line, cursor_column) do
+    Regex.scan(~r/\{([^{}]+)\}/, line, return: :index)
+    |> Enum.find_value(fn [{match_start, match_len}, {expr_start, expr_len}] ->
+      if cursor_column >= match_start and cursor_column < match_start + match_len do
+        expr = binary_part(line, expr_start, expr_len)
+        {:ok, String.to_charlist(expr)}
+      else
+        nil
+      end
+    end)
+  end
 end

apps/engine/test/engine/code_intelligence/entity_test.exs

@@ -983,6 +983,76 @@ defmodule Engine.CodeIntelligence.EntityTest do
       assert {:ok, {:call, MyLiveView, :button, 1}, _} = resolve(code)
     end
 
+    test "resolves shorthand component without closing tag with correct arity" do
+      code = ~q[
+        defmodule MyLiveView do
+          use Phoenix.Component
+
+          def render(assigns) do
+            ~H"""
+            <.but|ton label="Click" />
+            """
+          end
+
+          def button(assigns), do: nil
+        end
+      ]
+
+      assert {:ok, {:call, MyLiveView, :button, 1}, _} = resolve(code)
+    end
+
+    test "resolves shorthand component with curly braces with correct arity" do
+      code = ~q[
+        defmodule MyLiveView do
+          use Phoenix.Component
+
+          def render(assigns) do
+            ~H"""
+            <.but|ton label={label} />
+            """
+          end
+
+          def button(assigns), do: nil
+        end
+      ]
+
+      assert {:ok, {:call, MyLiveView, :button, 1}, _} = resolve(code)
+    end
+
+    test "resolves shorthand component with curly braces on the first line of sigil with correct arity" do
+      code = ~q[
+        defmodule MyLiveView do
+          use Phoenix.Component
+
+          def render(assigns) do
+            ~H"<.butto|n label={label} />"
+          end
+
+          def button(assigns), do: nil
+        end
+      ]
+
+      assert {:ok, {:call, MyLiveView, :button, 1}, _} = resolve(code)
+    end
+
+    test "resolves function called inside shorthand component with curly braces with correct arity" do
+      code = ~q[
+        defmodule MyLiveView do
+          use Phoenix.Component
+
+          def render(assigns) do
+            ~H"""
+            <.button label={LabelGenerator.for_bu|tton("label", in_live_view: true, language: :en)} />
+            """
+          end
+
+          def button(assigns), do: nil
+        end
+      ]
+
+      assert {:ok, {:call, LabelGenerator, :for_button, 2}, _} = resolve(code)
+    end
+
     test "resolves EEx expression with arity 1" do
       code = ~q[
         defmodule MyLiveView do