Format |> var.fun() calls as well

Author: sabiwara

lib/elixir/lib/code.ex

@@ -697,10 +697,11 @@ defmodule Code do
       Defaults to the value of the `:migrate` option. This option changes the AST.
 
     * `:migrate_call_parens_on_pipe` (since v1.19.0) - when `true`,
-      formats local calls on the right-hand side of the pipe operator to always
-      include parentheses, for example `foo |> bar` becomes `foo |> bar()`.
-      Parentheses are always added for qualified calls like `foo |> Bar.bar`
-      disregarding of this option.
+      formats calls on the right-hand side of the pipe operator to always include
+      parentheses, for example `foo |> bar` becomes `foo |> bar()` and
+      `foo |> mod.fun` becomes `foo |> mod.fun()`.
+      Parentheses are always added for qualified calls like `foo |> Bar.bar` even
+      when this option is `false`.
       Defaults to the value of the `:migrate` option. This option changes the AST.
 
     * `:migrate_charlists_as_sigils` (since v1.18.0) - when `true`,

lib/elixir/lib/code/formatter.ex

@@ -843,20 +843,38 @@ defmodule Code.Formatter do
     {wrap_in_parens(doc), state}
   end
 
+  # |> var
+  # |> var()
   defp binary_operand_to_algebra(
-         {var, meta, atom},
+         {var, meta, var_context},
          context,
          %{migrate_call_parens_on_pipe: true} = state,
          :|>,
          _parent_info,
          :right,
          _nesting
        )
-       when is_atom(var) and is_atom(atom) do
+       when is_atom(var) and is_atom(var_context) do
     operand = {var, meta, []}
     quoted_to_algebra(operand, context, state)
   end
 
+  # |> var.fun
+  # |> var.fun()
+  defp binary_operand_to_algebra(
+         {{:., _, [_, fun]} = call, meta, []},
+         context,
+         %{migrate_call_parens_on_pipe: true} = state,
+         :|>,
+         _parent_info,
+         :right,
+         _nesting
+       )
+       when is_atom(fun) do
+    meta = Keyword.put_new_lazy(meta, :closing, fn -> [line: meta[:line]] end)
+    quoted_to_algebra({call, meta, []}, context, state)
+  end
+
   defp binary_operand_to_algebra(operand, context, state, parent_op, parent_info, side, nesting) do
     {parent_assoc, parent_prec} = parent_info
 

lib/elixir/test/elixir/code_formatter/migration_test.exs

@@ -33,6 +33,8 @@ defmodule Code.Formatter.MigrationTest do
     test "adds parentheses on the right operand" do
       assert_format "x |> y", "x |> y()", @opts
       assert_format "x |> y |> z", "x |> y() |> z()", @opts
+      assert_format "x |> y.z", "x |> y.z()", @opts
+      assert_format "x |> y.z.t", "x |> y.z.t()", @opts
     end
 
     test "does nothing within defmacro" do
@@ -42,6 +44,7 @@ defmodule Code.Formatter.MigrationTest do
     test "does nothing without the migrate_unless option" do
       assert_same "x |> y"
       assert_same "x |> y |> z"
+      assert_same "x |> y.z"
     end
   end