Revert "if: drop empty do bodies. Closes #227"

This reverts commit 6b42462.

Author: novaugust

CHANGELOG.md

@@ -5,10 +5,6 @@ they can and will change without that change being reflected in Styler's semanti
 
 ## main
 
-### Improvements
-
-- `if`: drop empty `do` bodies like `if a, do: nil, else: b` => `if !a, do: b` (#227)
-
 ### Fixes
 
 - fix bug that mangled large blocks of comments when sorting in configs or with `# styler:sort` (#230, h/t @cschmatzler)

docs/control_flow_macros.md

@@ -21,8 +21,6 @@ We advocate for `case` and `if` as the first tools to be considered for any cont
 
 Never! `unless` [is being deprecated](https://github.com/elixir-lang/elixir/pull/13769#issuecomment-2334878315) and so should not be used.
 
-Styler replaces `unless` statements with their `if` equivalent similar to using the `mix format --migrate_unless` flag.
-
 ### use `with` when...
 
 > `with` great power comes great responsibility
@@ -58,26 +56,34 @@ if a, do: b, else: nil
 if a, do: b
 ```
 
-It also removes `do: nil` when an `else` is present, inverting the head to maintain semantics
-
-```elixir
-if a, do: nil, else: b
-# styled:
-if !a, do: b
-```
-
 ### Negation Inversion
 
-Styler removes negators in the head of `if` statements by "inverting" the statement.
+Styler removes negators in the head of `if` and `unless` statements by "inverting" the statement.
 The following operators are considered "negators": `!`, `not`, `!=`, `!==`
 
+
 Examples:
 
 ```elixir
+# negated `if` statement with no `else` clause are rewritten to `unless`
+if not x, do: y
+# Styled:
+unless x, do: y
+
 # negated `if` statements with an `else` clause have their clauses inverted and negation removed
 if !x, do: y, else: z
 # Styled:
 if x, do: z, else: y
+
+# negated `unless` statements are rewritten to `if`
+unless x != y, do: z
+# B styled:
+if x == y, do: z
+
+# `unless` with `else` is verboten; these are always rewritten to `if` statements
+unless x, do: y, else: z
+# styled:
+if x, do: z, else: y
 ```
 
 Because elixir relies on truthy/falsey values for its `if` statements, boolean casting is unnecessary and so double negation is simply removed.

lib/style/blocks.ex

@@ -31,7 +31,6 @@ defmodule Styler.Style.Blocks do
   alias Styler.Zipper
 
   defguardp is_negator(n) when elem(n, 0) in [:!, :not, :!=, :!==]
-  defguardp is_empty_body(n) when elem(n, 0) == :__block__ and elem(n, 2) in [[nil], []]
 
   # case statement with exactly 2 `->` cases
   # rewrite to `if` if it's any of 3 trivial cases
@@ -140,13 +139,13 @@ defmodule Styler.Style.Blocks do
       [negator, [{do_, do_body}, {else_, else_body}]] when is_negator(negator) ->
         zipper |> Zipper.replace({:if, m, [invert(negator), [{do_, else_body}, {else_, do_body}]]}) |> run(ctx)
 
-      # drop `else end` and `else: nil`
-      [head, [do_block, {_, else_body}]] when is_empty_body(else_body) ->
+      # drop `else end`
+      [head, [do_block, {_, {:__block__, _, []}}]] ->
         {:cont, Zipper.replace(zipper, {:if, m, [head, [do_block]]}), ctx}
 
-      # invert and drop `do: nil`
-      [head, [{do_, do_body}, {_, else_body}]] when is_empty_body(do_body) ->
-        {:cont, Zipper.replace(zipper, {:if, m, [invert(head), [{do_, else_body}]]}), ctx}
+      # drop `else: nil`
+      [head, [do_block, {_, {:__block__, _, [nil]}}]] ->
+        {:cont, Zipper.replace(zipper, {:if, m, [head, [do_block]]}), ctx}
 
       [head, [do_, else_]] ->
         if Style.max_line(do_) > Style.max_line(else_) do

test/style/blocks_test.exs

@@ -988,32 +988,6 @@ defmodule Styler.Style.BlocksTest do
       )
     end
 
-    test "inverts do nil" do
-      assert_style("if a, do: b, else: nil", "if a, do: b")
-
-      assert_style("if a do nil else b end", """
-      if !a do
-        b
-      end
-      """)
-
-      assert_style(
-        """
-        if a == b do
-          # comment
-        else
-          :ok
-        end
-        """,
-        """
-        if a != b do
-          # comment
-          :ok
-        end
-        """
-      )
-    end
-
     test "double negator rewrites" do
       for a <- ~w(not !), block <- ["do: z", "do: z, else: zz"] do
         assert_style "if #{a} (x != y), #{block}", "if x == y, #{block}"