fix test

Author: lukaszsamson

lib/elixir_sense/core/compiler/fn.ex

@@ -186,17 +186,16 @@ defmodule ElixirSense.Core.Compiler.Fn do
   defp escape({:&, meta, [pos]}, dict) when is_integer(pos) and pos > 0 do
     # This might pollute user space but is unlikely because variables
     # named :"&1" are not valid syntax.
-    var = {:"&#{pos}", meta, nil}
-    {var, :orddict.store(pos, var, dict)}
-
+    # NOTE: ElixirSense intentionally uses :"&#{pos}" instead of :capture atom
+    # (Elixir 1.17+ uses :capture) because :"&#{pos}" provides better variable intelligence
     case :orddict.find(pos, dict) do
       {:ok, var} ->
         {var, dict}
 
       :error ->
         # elixir uses here elixir_module:next_counter(?key(E, module))
         # but we are not compiling and do not need to keep count in module scope
-        # elixir 1.17 also renames the var to `capture`
+        # elixir 1.19 added {:capture, pos} metadata
         next = System.unique_integer()
         var = {:"&#{pos}", [{:counter, next}, {:capture, pos} | meta], nil}
         {var, :orddict.store(pos, var, dict)}

test/elixir_sense/core/compiler_test.exs

@@ -974,24 +974,38 @@ defmodule ElixirSense.Core.CompilerTest do
           {{{:., dot_meta, target}, call_meta, args}, state}
 
         {:fn, meta, args} = _node, state ->
-          meta =
-            if Version.match?(System.version(), "< 1.19.0") do
-              Keyword.delete(meta, :capture)
-            else
-              meta
-            end
-
+          # Always remove {:capture, true} metadata for normalization
+          # Both ElixirSense and Elixir >= 1.19 produce it, so normalize it away
+          meta = Keyword.delete(meta, :capture)
           {{:fn, meta, args}, state}
 
         {atom, meta, nil} = node, state when is_atom(atom) ->
-          # elixir changes the name to capture and does different counter tracking
+          # ElixirSense intentionally uses :"&#{pos}" instead of :capture
+          # Convert to :capture to match Elixir 1.17+ behavior
           node =
-            with "&" <> int <- to_string(atom), {_, ""} <- Integer.parse(int) do
+            with "&" <> int <- to_string(atom), {pos, ""} <- Integer.parse(int) do
+              # Normalize metadata
               meta =
-                Keyword.delete(meta, :counter)
-                |> Keyword.delete(:capture)
-
-              {:capture, meta, nil}
+                if Version.match?(System.version(), "< 1.17.0") do
+                  # Elixir < 1.17 used :"&#{pos}" with no special metadata
+                  Keyword.delete(meta, :counter) |> Keyword.delete(:capture)
+                else
+                  # Elixir >= 1.17 uses :capture atom
+                  if Version.match?(System.version(), "< 1.19.0") do
+                    # Elixir 1.17-1.18: no {:capture, pos} metadata
+                    Keyword.delete(meta, :counter) |> Keyword.delete(:capture)
+                  else
+                    # Elixir >= 1.19: has {:capture, pos} metadata, remove :counter only
+                    Keyword.delete(meta, :counter)
+                  end
+                end
+
+              # Convert to :capture for Elixir 1.17+
+              if Version.match?(System.version(), "< 1.17.0") do
+                {atom, meta, nil}
+              else
+                {:capture, meta, nil}
+              end
             else
               _ -> node
             end
@@ -1019,28 +1033,37 @@ defmodule ElixirSense.Core.CompilerTest do
           {{:->, meta, args}, state}
 
         {:fn, meta, args} = _node, state ->
-          meta =
-            if Version.match?(System.version(), ">= 1.19.0-rc.0") do
-              Keyword.delete(meta, :capture)
-            else
-              meta
-            end
-
+          # Normalize :capture metadata - always remove for comparison
+          # (ElixirSense normalizes this too)
+          meta = Keyword.delete(meta, :capture)
           {{:fn, meta, args}, state}
 
         {:capture, meta, nil} = _node, state ->
-          # elixir changes the name to capture and does different counter tracking
-          meta = Keyword.delete(meta, :counter)
-
+          # Normalize capture variable metadata
+          # Always remove :counter and optionally :capture depending on version
           meta =
-            if Version.match?(System.version(), ">= 1.19.0-rc.0") do
-              Keyword.delete(meta, :capture)
+            if Version.match?(System.version(), "< 1.19.0") do
+              # Elixir < 1.19: remove both counter and capture metadata
+              Keyword.delete(meta, :counter) |> Keyword.delete(:capture)
             else
-              meta
+              # Elixir >= 1.19: keep :capture but remove :counter
+              Keyword.delete(meta, :counter)
             end
 
           {{:capture, meta, nil}, state}
 
+        {atom, meta, nil} = node, state when is_atom(atom) ->
+          # Handle old :"&#{pos}" format from Elixir < 1.18
+          node =
+            with "&" <> int <- to_string(atom), {_, ""} <- Integer.parse(int) do
+              meta = Keyword.delete(meta, :counter) |> Keyword.delete(:capture)
+              {atom, meta, nil}
+            else
+              _ -> node
+            end
+
+          {node, state}
+
         node, state ->
           {node, state}
       end)