Allow groups to inherit the parent break

Author: José Valim

lib/elixir/lib/code/formatter.ex

@@ -1050,7 +1050,7 @@ defmodule Code.Formatter do
   defp call_args_to_algebra_with_no_parens_keywords(left, right, context, state) do
     {left_doc, state} = args_to_algebra(left, state, &quoted_to_algebra(&1, context, &2))
     {right_doc, state} = quoted_to_algebra(right, context, state)
-    right_doc = break(" ") |> concat(right_doc) |> group()
+    right_doc = break(" ") |> concat(right_doc) |> group(:inherit)
 
     doc =
       with_next_break_fits(true, right_doc, fn right_doc ->

lib/elixir/lib/inspect/algebra.ex

@@ -209,9 +209,9 @@ defmodule Inspect.Algebra do
     quote do: {:doc_break, unquote(break), unquote(mode)}
   end
 
-  @typep doc_group :: {:doc_group, t}
-  defmacrop doc_group(group) do
-    quote do: {:doc_group, unquote(group)}
+  @typep doc_group :: {:doc_group, t, :inherit | :self}
+  defmacrop doc_group(group, mode) do
+    quote do: {:doc_group, unquote(group), unquote(mode)}
   end
 
   @typep doc_fits :: {:doc_fits, t, :enabled | :disabled}
@@ -695,8 +695,8 @@ defmodule Inspect.Algebra do
 
   """
   @spec group(t) :: doc_group
-  def group(doc) when is_doc(doc) do
-    doc_group(doc)
+  def group(doc, mode \\ :self) when is_doc(doc) do
+    doc_group(doc, mode)
   end
 
   @doc ~S"""
@@ -812,12 +812,12 @@ defmodule Inspect.Algebra do
   defp fits?(_, _, []),                                      do: true
 
   defp fits?(w, k, [{i, _, doc_fits(x, :disabled)} | t]),    do: fits?(w, k, [{i, :no_fitting, x} | t])
-  defp fits?(w, k, [{i, :no_fitting, doc_group(x)} | t]),    do: fits?(w, k, [{i, :no_fitting, x} | t])
+  defp fits?(w, k, [{i, :no_fitting, doc_group(x, _)} | t]), do: fits?(w, k, [{i, :no_fitting, x} | t])
   defp fits?(w, k, [{i, :no_fitting, doc_fits(x, _)} | t]),  do: fits?(w, k, [{i, :no_fitting, x} | t])
 
   defp fits?(w, k, [{i, _, doc_fits(x, :enabled)} | t]),     do: fits?(w, k, [{i, :next_fits, x} | t])
   defp fits?(w, k, [{i, :next_fits, doc_force(x)} | t]),     do: fits?(w, k, [{i, :next_fits, x} | t])
-  defp fits?(w, k, [{i, :next_fits, doc_group(x)} | t]),     do: fits?(w, k, [{i, :next_fits, x} | t])
+  defp fits?(w, k, [{i, :next_fits, doc_group(x, _)} | t]),  do: fits?(w, k, [{i, :next_fits, x} | t])
   defp fits?(_, _, [{_, :next_fits, doc_break(_, _)} | _]),  do: true
   defp fits?(_, _, [{_, :next_fits, :doc_line} | _]),        do: true
 
@@ -828,7 +828,7 @@ defmodule Inspect.Algebra do
   defp fits?(w, k, [{i, m, doc_color(x, _)} | t]),           do: fits?(w, k, [{i, m, x} | t])
   defp fits?(w, k, [{i, m, doc_nest(x, _, :break)} | t]),    do: fits?(w, k, [{i, m, x} | t])
   defp fits?(w, k, [{i, m, doc_nest(x, j, _)} | t]),         do: fits?(w, k, [{apply_nesting(i, k, j), m, x} | t])
-  defp fits?(w, k, [{i, _, doc_group(x)} | t]),              do: fits?(w, k, [{i, :flat, x} | t])
+  defp fits?(w, k, [{i, _, doc_group(x, _)} | t]),           do: fits?(w, k, [{i, :flat, x} | t])
   defp fits?(w, k, [{_, _, doc_string(_, l)} | t]),          do: fits?(w, k + l, t)
   defp fits?(w, k, [{_, _, s} | t]) when is_binary(s),       do: fits?(w, k + byte_size(s), t)
   defp fits?(_, _, [{_, _, doc_force(_)} | _]),              do: false
@@ -877,7 +877,11 @@ defmodule Inspect.Algebra do
   end
 
   # Groups must do the fitting decision.
-  defp format(w, k, [{i, _, doc_group(x)} | t]) do
+  defp format(w, k, [{i, :break, doc_group(x, :inherit)} | t]) do
+    format(w, k, [{i, :break, x} | t])
+  end
+
+  defp format(w, k, [{i, _, doc_group(x, _)} | t]) do
     if w == :infinity or fits?(w, k, [{i, :flat, x}]) do
       format(w, k, [{i, :flat, x} | t])
     else

lib/elixir/test/elixir/code_formatter/general_test.exs

@@ -678,7 +678,7 @@ bar)
       """
     end
 
-    test "as funciton arguments" do
+    test "as function arguments" do
       assert_same """
       fun(
         (

lib/elixir/test/elixir/code_formatter/integration_test.exs

@@ -180,4 +180,16 @@ defmodule Code.Formatter.IntegrationTest do
     end)
     """
   end
+
+  test "long comprehension" do
+    assert_same """
+    for %{app: app, opts: opts, top_level: true} <- Mix.Dep.cached(),
+        Keyword.get(opts, :app, true),
+        Keyword.get(opts, :runtime, true),
+        not Keyword.get(opts, :optional, false),
+        app not in included_applications,
+        app not in included_applications,
+        do: app
+    """
+  end
 end