Ensure do blocks do not exceed line length on single arguments

Closes #7232

Author: José Valim

lib/elixir/lib/code/formatter.ex

@@ -276,7 +276,8 @@ defmodule Code.Formatter do
   defp next_eol('\r\n' ++ rest, count), do: next_eol(rest, count + 1)
   defp next_eol(_, count), do: count
 
-  defp previous_eol([{token, {_, _, count}} | _]) when token in [:eol, :",", :";"] and count > 0 do
+  defp previous_eol([{token, {_, _, count}} | _])
+       when token in [:eol, :",", :";"] and count > 0 do
     count
   end
 
@@ -453,7 +454,8 @@ defmodule Code.Formatter do
     {atom_to_algebra(atom), state}
   end
 
-  defp quoted_to_algebra({:__block__, meta, [integer]}, _context, state) when is_integer(integer) do
+  defp quoted_to_algebra({:__block__, meta, [integer]}, _context, state)
+       when is_integer(integer) do
     {integer_to_algebra(Keyword.fetch!(meta, :original)), state}
   end
 
@@ -915,7 +917,8 @@ defmodule Code.Formatter do
   # Mod.function()
   # var.function
   # expression.function(arguments)
-  defp remote_to_algebra({{:., _, [target, fun]}, meta, args}, context, state) when is_atom(fun) do
+  defp remote_to_algebra({{:., _, [target, fun]}, meta, args}, context, state)
+       when is_atom(fun) do
     {target_doc, state} = remote_target_to_algebra(target, state)
     fun = remote_fun_to_algebra(target, fun, length(args), state)
     remote_doc = target_doc |> concat(".") |> concat(string(fun))
@@ -1082,6 +1085,10 @@ defmodule Code.Formatter do
           &quoted_to_algebra(&1, context, &2)
         )
 
+      # If we have a single argument, then we won't have an option to break
+      # before the "extra" part, so we ungroup it and build it later.
+      args_doc = ungroup_if_group(args_doc)
+
       doc =
         if skip_parens? do
           " "
@@ -1196,7 +1203,8 @@ defmodule Code.Formatter do
     ["\n" | entries]
   end
 
-  defp interpolation_to_algebra([entry | entries], escape, state, acc, last) when is_binary(entry) do
+  defp interpolation_to_algebra([entry | entries], escape, state, acc, last)
+       when is_binary(entry) do
     acc = concat(acc, escape_string(entry, escape))
     interpolation_to_algebra(entries, escape, state, acc, last)
   end
@@ -2041,6 +2049,9 @@ defmodule Code.Formatter do
 
   ## Algebra helpers
 
+  defp ungroup_if_group({:doc_group, group, _mode}), do: group
+  defp ungroup_if_group(other), do: other
+
   defp format_to_string(doc) do
     doc |> Inspect.Algebra.format(:infinity) |> IO.iodata_to_binary()
   end

lib/elixir/lib/gen_server.ex

@@ -885,7 +885,8 @@ defmodule GenServer do
   See `multi_call/4` for more information.
   """
   @spec abcast([node], name :: atom, term) :: :abcast
-  def abcast(nodes \\ [node() | Node.list()], name, request) when is_list(nodes) and is_atom(name) do
+  def abcast(nodes \\ [node() | Node.list()], name, request)
+      when is_list(nodes) and is_atom(name) do
     msg = cast_msg(request)
     _ = for node <- nodes, do: do_send({name, node}, msg)
     :abcast

lib/elixir/lib/inspect/algebra.ex

@@ -934,7 +934,7 @@ defmodule Inspect.Algebra do
     do: fits?(w, k, b?, [{apply_nesting(i, k, j), m, x} | t])
 
   defp fits?(w, k, b?, [{i, m, doc_cons(x, y)} | t]),
-    do: fits?(w, k, b?, [{i, m, x} | [{i, m, y} | t]])
+    do: fits?(w, k, b?, [{i, m, x}, {i, m, y} | t])
 
   defp fits?(w, k, b?, [{i, m, doc_group(x, _)} | t]),
     do: fits?(w, k, b?, [{i, m, x} | {:tail, b?, t}])
@@ -943,7 +943,7 @@ defmodule Inspect.Algebra do
   defp format(_, _, []), do: []
   defp format(w, k, [{_, _, :doc_nil} | t]), do: format(w, k, t)
   defp format(w, _, [{i, _, :doc_line} | t]), do: [indent(i) | format(w, i, t)]
-  defp format(w, k, [{i, m, doc_cons(x, y)} | t]), do: format(w, k, [{i, m, x} | [{i, m, y} | t]])
+  defp format(w, k, [{i, m, doc_cons(x, y)} | t]), do: format(w, k, [{i, m, x}, {i, m, y} | t])
   defp format(w, k, [{i, m, doc_color(x, c)} | t]), do: [ansi(c) | format(w, k, [{i, m, x} | t])]
   defp format(w, k, [{_, _, doc_string(s, l)} | t]), do: [s | format(w, k + l, t)]
   defp format(w, k, [{_, _, s} | t]) when is_binary(s), do: [s | format(w, k + byte_size(s), t)]

lib/elixir/lib/kernel.ex

@@ -3330,7 +3330,8 @@ defmodule Kernel do
     :lists.mapfoldl(fun, acc, list)
   end
 
-  defp ensure_evaled_element(elem, acc) when is_number(elem) or is_atom(elem) or is_binary(elem) do
+  defp ensure_evaled_element(elem, acc)
+       when is_number(elem) or is_atom(elem) or is_binary(elem) do
     {elem, acc}
   end
 

lib/elixir/lib/map_set.ex

@@ -150,7 +150,8 @@ defmodule MapSet do
   # If the first set is less than twice the size of the second map,
   # it is fastest to re-accumulate items in the first set that are not
   # present in the second set.
-  def difference(%MapSet{map: map1}, %MapSet{map: map2}) when map_size(map1) < map_size(map2) * 2 do
+  def difference(%MapSet{map: map1}, %MapSet{map: map2})
+      when map_size(map1) < map_size(map2) * 2 do
     map =
       map1
       |> Map.keys()

lib/elixir/lib/module/locals_tracker.ex

@@ -61,7 +61,8 @@ defmodule Module.LocalsTracker do
   @doc """
   Adds an import dispatch to the given target.
   """
-  def add_import(d, function, module, {name, arity}) when is_tuple(function) and is_atom(module) do
+  def add_import(d, function, module, {name, arity})
+      when is_tuple(function) and is_atom(module) do
     tuple = {:import, name, arity}
     put_edge(d, tuple, module)
     put_edge(d, function, tuple)

lib/elixir/lib/regex.ex

@@ -465,7 +465,8 @@ defmodule Regex do
     end
   end
 
-  def split(%Regex{re_pattern: compiled}, string, opts) when is_binary(string) and is_list(opts) do
+  def split(%Regex{re_pattern: compiled}, string, opts)
+      when is_binary(string) and is_list(opts) do
     on = Keyword.get(opts, :on, :first)
 
     case :re.run(string, compiled, [:global, capture: on]) do
@@ -653,7 +654,8 @@ defmodule Regex do
     string
   end
 
-  defp apply_list(whole, string, pos, replacement, [[{mpos, _} | _] | _] = list) when mpos > pos do
+  defp apply_list(whole, string, pos, replacement, [[{mpos, _} | _] | _] = list)
+       when mpos > pos do
     length = mpos - pos
     <<untouched::binary-size(length), rest::binary>> = string
     [untouched | apply_list(whole, rest, mpos, replacement, list)]

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

@@ -345,7 +345,7 @@ defmodule Code.Formatter.IntegrationTest do
     """
   end
 
-  test "no parens keywords right on line limit" do
+  test "no parens keywords at the end of the line" do
     bad = """
     defmodule Mod do
       defp token_list_downcase(<<char, rest::binary>>, acc) when is_whitespace(char) or is_comma(char), do: token_list_downcase(rest, acc)
@@ -382,6 +382,25 @@ defmodule Code.Formatter.IntegrationTest do
     assert_format bad, good, line_length: 18
   end
 
+  test "do at the end of the line with single argument" do
+    bad = """
+    defmodule Location do
+      def new(line, column) when is_integer(line) and line >= 0 and is_integer(column) and column >= 0 do
+        %{column: column, line: line}
+      end
+    end
+    """
+
+    assert_format bad, """
+    defmodule Location do
+      def new(line, column)
+          when is_integer(line) and line >= 0 and is_integer(column) and column >= 0 do
+        %{column: column, line: line}
+      end
+    end
+    """
+  end
+
   test "tuples as trees" do
     bad = """
     @document Parser.parse(

lib/logger/lib/logger.ex

@@ -605,7 +605,8 @@ defmodule Logger do
   """
   @spec bare_log(level, message | (() -> message | {message, keyword}), keyword) ::
           :ok | {:error, :noproc} | {:error, term}
-  def bare_log(level, chardata_or_fun, metadata \\ []) when level in @levels and is_list(metadata) do
+  def bare_log(level, chardata_or_fun, metadata \\ [])
+      when level in @levels and is_list(metadata) do
     case __metadata__() do
       {true, pdict} ->
         %{mode: mode, truncate: truncate, level: min_level, utc_log: utc_log?} =