Wrap (a -> b) into literals instead of plain lists, closes #13358

Author: josevalim

lib/elixir/lib/code/formatter.ex

@@ -367,6 +367,11 @@ defmodule Code.Formatter do
     tuple_to_algebra(meta, [left, right], :flex_break, state)
   end
 
+  # (left -> right)
+  defp quoted_to_algebra({:__block__, _, [[{:->, _, _} | _] = clauses]}, _context, state) do
+    paren_fun_to_algebra(clauses, @max_line, @min_line, state)
+  end
+
   defp quoted_to_algebra({:__block__, meta, [list]}, _context, state) when is_list(list) do
     case meta[:delimiter] do
       ~s['''] ->
@@ -417,6 +422,7 @@ defmodule Code.Formatter do
     {Keyword.fetch!(meta, :token) |> float_to_algebra(state.inspect_opts), state}
   end
 
+  # (unquote_splicing(...))
   defp quoted_to_algebra(
          {:__block__, _meta, [{:unquote_splicing, meta, [_] = args}]},
          context,
@@ -505,11 +511,6 @@ defmodule Code.Formatter do
     remote_to_algebra(quoted, context, state)
   end
 
-  # (left -> right)
-  defp quoted_to_algebra([{:->, _, _} | _] = clauses, _context, state) do
-    paren_fun_to_algebra(clauses, @max_line, @min_line, state)
-  end
-
   # [keyword: :list] (inner part)
   # %{:foo => :bar} (inner part)
   defp quoted_to_algebra(list, context, state) when is_list(list) do

lib/elixir/lib/code/normalizer.ex

@@ -137,11 +137,6 @@ defmodule Code.Normalizer do
     {:., meta, [left, right]}
   end
 
-  # A list of left to right arrows is not considered as a list literal, so it's not wrapped
-  defp do_normalize([{:->, _, [_ | _]} | _] = quoted, state) do
-    normalize_args(quoted, state)
-  end
-
   # left -> right
   defp do_normalize({:->, meta, [left, right]}, state) do
     meta = patch_meta_line(meta, state.parent_meta)

lib/elixir/src/elixir_parser.yrl

@@ -789,12 +789,14 @@ adjust_map_column(Map) ->
 
 %% Blocks
 
-build_block([{unquote_splicing, _, [_]}]=Exprs) ->
-  {'__block__', [], Exprs};
-build_block([Expr]) ->
+build_block(Exprs) -> build_block(Exprs, []).
+
+build_block([{unquote_splicing, _, [_]}]=Exprs, Meta) ->
+  {'__block__', Meta, Exprs};
+build_block([Expr], _Meta) ->
   Expr;
-build_block(Exprs) ->
-  {'__block__', [], Exprs}.
+build_block(Exprs, Meta) ->
+  {'__block__', Meta, Exprs}.
 
 %% Newlines
 
@@ -1072,11 +1074,9 @@ build_stab(Stab) ->
 build_paren_stab(_Before, [{Op, _, [_]}]=Exprs, _After) when ?rearrange_uop(Op) ->
   {'__block__', [], Exprs};
 build_paren_stab(Before, Stab, After) ->
-  case build_stab(Stab) of
-    {'__block__', Meta, Block} ->
-      {'__block__', Meta ++ meta_from_token_with_closing(Before, After), Block};
-    Other ->
-      Other
+  case check_stab(Stab, none) of
+    block -> build_block(reverse(Stab), meta_from_token_with_closing(Before, After));
+    stab -> handle_literal(collect_stab(Stab, [], []), Before, newlines_pair(Before, After))
   end.
 
 collect_stab([{'->', Meta, [Left, Right]} | T], Exprs, Stabs) ->

lib/elixir/test/elixir/kernel/parser_test.exs

@@ -474,6 +474,56 @@ defmodule Kernel.ParserTest do
                 ]}
     end
 
+    test "end of expression with literal" do
+      file = """
+      a do
+        d ->
+          (
+            b -> c
+          )
+      end
+      """
+
+      assert Code.string_to_quoted!(file,
+               token_metadata: true,
+               literal_encoder: &{:ok, {:__block__, &2, [&1]}}
+             ) ==
+               {:a,
+                [
+                  end_of_expression: [newlines: 1, line: 6],
+                  do: [line: 1],
+                  end: [line: 6],
+                  line: 1
+                ],
+                [
+                  [
+                    {{:__block__, [line: 1], [:do]},
+                     [
+                       {:->, [newlines: 1, line: 2],
+                        [
+                          [{:d, [line: 2], nil}],
+                          {:__block__,
+                           [
+                             end_of_expression: [newlines: 1, line: 5],
+                             newlines: 1,
+                             closing: [line: 5],
+                             line: 3
+                           ],
+                           [
+                             [
+                               {:->, [line: 4],
+                                [
+                                  [{:b, [line: 4], nil}],
+                                  {:c, [end_of_expression: [newlines: 1, line: 4], line: 4], nil}
+                                ]}
+                             ]
+                           ]}
+                        ]}
+                     ]}
+                  ]
+                ]}
+    end
+
     test "does not add end of expression to ->" do
       file = """
       case true do
@@ -551,7 +601,7 @@ defmodule Kernel.ParserTest do
                 [
                   {:->, [line: 1],
                    [
-                     [{:__block__, [token: "1", line: 1, closing: [line: 1], line: 1], [1]}],
+                     [{:__block__, [token: "1", line: 1], [1]}],
                      {:__block__, [delimiter: "\"", line: 1], ["hello"]}
                    ]}
                 ]}