Fix flex break at group end

Author: josevalim

Diff for: lib/elixir/lib/code/formatter.ex

@@ -802,30 +802,30 @@ defmodule Code.Formatter do
     {right, state} =
       binary_operand_to_algebra(right_arg, right_context, state, op, op_info, :right, 0)
 
-    doc =
+    {op_string, right} =
       cond do
         op in @no_space_binary_operators ->
-          op_doc = color_doc(op_string, :operator, state.inspect_opts)
-          concat(concat(group(left), op_doc), group(right))
+          {op_string, group(right)}
 
         op in @no_newline_binary_operators ->
-          op_doc = color_doc(" " <> op_string <> " ", :operator, state.inspect_opts)
-          concat(concat(group(left), op_doc), group(right))
+          {" " <> op_string <> " ", group(right)}
 
         true ->
           eol? = eol?(meta, state)
 
           next_break_fits? =
             op in @next_break_fits_operators and next_break_fits?(right_arg, state) and not eol?
 
-          with_next_break_fits(next_break_fits?, right, fn right ->
-            op_doc = color_doc(" " <> op_string, :operator, state.inspect_opts)
-            right = nest(glue(op_doc, group(right)), nesting, :break)
-            right = if eol?, do: force_unfit(right), else: right
-            concat(group(left), group(right))
-          end)
+          {" " <> op_string,
+           with_next_break_fits(next_break_fits?, right, fn right ->
+             right = nest(concat(break(), group(right)), nesting, :break)
+             right = if eol?, do: force_unfit(right), else: right
+             group(right)
+           end)}
       end
 
+    op_doc = color_doc(op_string, :operator, state.inspect_opts)
+    doc = concat(concat(group(left), op_doc), group(right))
     {doc, state}
   end
 

Diff for: lib/elixir/lib/inspect/algebra.ex

@@ -1031,7 +1031,10 @@ defmodule Inspect.Algebra do
           entries
         ) :: :fit | :no_fit | :break_next
         when entries:
-               maybe_improper_list({integer(), mode(), t()}, {:tail, boolean(), entries} | [])
+               maybe_improper_list(
+                 {integer(), mode(), t()} | :group_over,
+                 {:tail, boolean(), entries} | []
+               )
 
   # We need at least a break to consider the document does not fit since a
   # large document without breaks has no option but fitting its current line.
@@ -1066,6 +1069,17 @@ defmodule Inspect.Algebra do
     end
   end
 
+  ## Group over
+  # If we get to the end of the group and if fits, it is because
+  # something already broke elsewhere, so we can consider the group
+  # fits. This only appears when checking if a flex break fits.
+
+  defp fits(_w, _k, true, [:group_over | _]),
+    do: :fit
+
+  defp fits(w, k, b?, [:group_over | t]),
+    do: fits(w, k, b?, t)
+
   ## Breaks
 
   defp fits(_, _, _, [{_, :break, doc_break(_, _)} | _]), do: :fit
@@ -1104,7 +1118,7 @@ defmodule Inspect.Algebra do
   @spec format(
           width :: non_neg_integer() | :infinity,
           column :: non_neg_integer(),
-          [{integer, mode, t}]
+          [{integer, mode, t} | :group_over]
         ) :: [binary]
   defp format(_, _, []), do: []
   defp format(w, k, [{_, _, :doc_nil} | t]), do: format(w, k, t)
@@ -1121,7 +1135,7 @@ defmodule Inspect.Algebra do
   defp format(w, k, [{i, m, doc_fits(x, _)} | t]), do: format(w, k, [{i, m, x} | t])
   defp format(w, _, [{i, _, doc_collapse(max)} | t]), do: collapse(format(w, i, t), max, 0, i)
 
-  # Flex breaks are not conditional to the mode
+  # Flex breaks are conditional to the document and the mode
   defp format(w, k, [{i, m, doc_break(s, :flex)} | t]) do
     k = k + byte_size(s)
 
@@ -1151,6 +1165,10 @@ defmodule Inspect.Algebra do
   end
 
   # Groups must do the fitting decision.
+  defp format(w, k, [:group_over | t]) do
+    format(w, k, t)
+  end
+
   defp format(w, k, [{i, :break, doc_group(x, :inherit)} | t]) do
     format(w, k, [{i, :break, x} | t])
   end
@@ -1164,8 +1182,8 @@ defmodule Inspect.Algebra do
 
     case fits do
       :fit -> format(w, k, [{i, :flat, x} | t])
-      :no_fit -> format(w, k, [{i, :break, x} | t])
-      :break_next -> format(w, k, [{i, :flat_no_break, x} | t])
+      :no_fit -> format(w, k, [{i, :break, x}, :group_over | t])
+      :break_next -> format(w, k, [{i, :flat_no_break, x}, :group_over | t])
     end
   end
 

Diff for: lib/elixir/test/elixir/code_formatter/integration_test.exs

@@ -465,6 +465,16 @@ defmodule Code.Formatter.IntegrationTest do
     """
   end
 
+  test "nested tuples as lines" do
+    assert_same """
+                {:ok,
+                 {1, 2, 3,
+                  4, 5}} =
+                  call()
+                """,
+                line_length: 10
+  end
+
   test "first argument in a call without parens with comments" do
     assert_same """
     with bar ::