MapMap: prefer f2's iter-var name when only f2 names it

Reported by Cursor Bugbot: the comment on iteration_var_name said
"if either side is an inline fn x -> ...", but the function only
inspected f1. When f1 was a capture (e.g. &Mod.foo/1) and f2 was
fn descriptive_name -> ..., the merged lambda defaulted to :arg1
instead of using f2's more meaningful name.

Author: JesseHerrick

lib/style/pipes.ex

@@ -436,7 +436,7 @@ defmodule Styler.Style.Pipes do
          ) = node
        ) do
     with true <- inlineable?(f1) and inlineable?(f2) and placeholder_in_first_position?(f2),
-         item_name = iteration_var_name(f1),
+         item_name = iteration_var_name(f1, f2),
          false <- shadows_free_var?(item_name, f1, f2),
          item = {item_name, [line: fm[:line]], nil},
          inlined_f1 = inline_capture(f1, item, fm[:line]),
@@ -629,11 +629,13 @@ defmodule Styler.Style.Pipes do
   defp inlineable?(_), do: false
 
   # If either side is an inline `fn x -> ...`, prefer that var name for the merged lambda - the source already named the
-  # iteration value. Otherwise, fall back to `arg1`.
-  defp iteration_var_name({:fn, _, [{:->, _, [[{name, _, ctx}], _]}]}) when is_atom(name) and is_atom(ctx) and name != :_,
+  # iteration value. Prefer f1's name when both are named. Otherwise, fall back to `arg1`.
+  defp iteration_var_name(f1, f2), do: fn_var_name(f1) || fn_var_name(f2) || :arg1
+
+  defp fn_var_name({:fn, _, [{:->, _, [[{name, _, ctx}], _]}]}) when is_atom(name) and is_atom(ctx) and name != :_,
     do: name
 
-  defp iteration_var_name(_), do: :arg1
+  defp fn_var_name(_), do: nil
 
   # The merged lambda introduces a fresh binding for `name`. If that same name appears as a free variable in either
   # side's body, it referred to a closure binding in the source - after merging, the new lambda's parameter would shadow

test/style/pipes_test.exs

@@ -790,15 +790,16 @@ defmodule Styler.Style.PipesTest do
     test "MapMap: pivots on the first arg of f1 when its placeholder isn't there" do
       # User case from billing_core/.../process_bloomberg_import.ex. Both sides are inlineable;
       # f1 puts the placeholder in position 2, so the merge pivots on `import_record` (f1's first
-      # arg) and the iter-var defaults to `arg1` since neither side is an inline `fn x -> ...`.
+      # arg). f1 is a capture so contributes no name; the merged lambda picks up `changeset` from
+      # f2's `fn changeset -> ...`.
       assert_style(
         """
         list
         |> Enum.map(&build_changeset(import_record, &1))
         |> Enum.map(fn changeset -> Repo.insert(changeset, on_conflict: :nothing) end)
         """,
         """
-        Enum.map(list, fn arg1 -> import_record |> build_changeset(arg1) |> Repo.insert(on_conflict: :nothing) end)
+        Enum.map(list, fn changeset -> import_record |> build_changeset(changeset) |> Repo.insert(on_conflict: :nothing) end)
         """
       )
     end
@@ -869,11 +870,12 @@ defmodule Styler.Style.PipesTest do
       |> Enum.map(&apply_with(&1, config))
       """)
 
-      # Default `:arg1` iter-var case: a closure named `arg1` in f1 must also block the merge.
+      # Default `:arg1` iter-var case (neither side names its iter-var): a closure named `arg1` in
+      # f1 must also block the merge.
       assert_style("""
       list
       |> Enum.map(&build_changeset(arg1, &1))
-      |> Enum.map(fn cs -> Repo.insert(cs) end)
+      |> Enum.map(&Repo.insert/1)
       """)
     end