Add metadata about single-expression block closing/opening (#13940)

Author: jonatanklosko

lib/elixir/src/elixir_parser.yrl

@@ -672,15 +672,15 @@ meta_from_location({Line, Column, _}) ->
 do_end_meta(Do, End) ->
   case ?token_metadata() of
     true ->
-      [{do, meta_from_location(?location(Do))}, {'end', meta_from_location(?location(End))}];
+      [{do, meta_from_token(Do)}, {'end', meta_from_token(End)}];
     false ->
       []
   end.
 
 meta_from_token_with_closing(Begin, End) ->
   case ?token_metadata() of
     true ->
-      [{closing, meta_from_location(?location(End))} | meta_from_token(Begin)];
+      [{closing, meta_from_token(End)} | meta_from_token(Begin)];
     false ->
       meta_from_token(Begin)
   end.
@@ -778,21 +778,42 @@ build_map_update(Left, {Pipe, Struct, Map}, Right, Extra) ->
 
 %% Blocks
 
-build_block(Exprs) -> build_block(Exprs, []).
+build_block(Exprs) -> build_block(Exprs, none).
 
-build_block([{unquote_splicing, _, [_]}]=Exprs, Meta) ->
-  {'__block__', Meta, Exprs};
-build_block([Expr], _Meta) ->
+build_block([{unquote_splicing, _, [_]}]=Exprs, BeforeAfter) ->
+  {'__block__', block_meta(BeforeAfter), Exprs};
+build_block([{Op, ExprMeta, Args}], {Before, After}) ->
+  ExprMetaWithExtra =
+    case ?token_metadata() of
+      true ->
+        ParensEntry = meta_from_token(Before) ++ [{closing, meta_from_token(After)}],
+        case ExprMeta of
+          % If there are multiple parens, those will result in subsequent
+          % build_block/2 calls, so we can assume parens entry is first
+          [{parens, Parens} | Meta] ->
+            [{parens, [ParensEntry | Parens]} | Meta];
+
+          Meta ->
+            [{parens, [ParensEntry]} | Meta]
+        end;
+      false ->
+        ExprMeta
+    end,
+  {Op, ExprMetaWithExtra, Args};
+build_block([Expr], _BeforeAfter) ->
   Expr;
-build_block(Exprs, Meta) ->
-  {'__block__', Meta, Exprs}.
+build_block(Exprs, BeforeAfter) ->
+  {'__block__', block_meta(BeforeAfter), Exprs}.
+
+block_meta(none) -> [];
+block_meta({Before, After}) -> meta_from_token_with_closing(Before, After).
 
 %% Newlines
 
 newlines_pair(Left, Right) ->
   case ?token_metadata() of
     true ->
-      newlines(?location(Left), [{closing, meta_from_location(?location(Right))}]);
+      newlines(?location(Left), [{closing, meta_from_token(Right)}]);
     false ->
       []
   end.
@@ -1064,7 +1085,7 @@ build_paren_stab(_Before, [{Op, _, [_]}]=Exprs, _After) when ?rearrange_uop(Op)
   {'__block__', [], Exprs};
 build_paren_stab(Before, Stab, After) ->
   case check_stab(Stab, none) of
-    block -> build_block(reverse(Stab), meta_from_token_with_closing(Before, After));
+    block -> build_block(reverse(Stab), {Before, After});
     stab -> handle_literal(collect_stab(Stab, [], []), Before, newlines_pair(Before, After))
   end.
 

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

@@ -609,6 +609,39 @@ defmodule Kernel.ParserTest do
                 [[do: {:__block__, [], []}]]}
     end
 
+    test "adds opening and closing information for single-expression block" do
+      file = "1 + (2 + 3)"
+
+      assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==
+               {:+, [line: 1, column: 3],
+                [
+                  1,
+                  {:+,
+                   [
+                     parens: [[line: 1, column: 5, closing: [line: 1, column: 11]]],
+                     line: 1,
+                     column: 8
+                   ], [2, 3]}
+                ]}
+
+      file = "1 + ((2 + 3))"
+
+      assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==
+               {:+, [line: 1, column: 3],
+                [
+                  1,
+                  {:+,
+                   [
+                     parens: [
+                       [line: 1, column: 5, closing: [line: 1, column: 13]],
+                       [line: 1, column: 6, closing: [line: 1, column: 12]]
+                     ],
+                     line: 1,
+                     column: 9
+                   ], [2, 3]}
+                ]}
+    end
+
     test "with :literal_encoder" do
       opts = [literal_encoder: &{:ok, {:__block__, &2, [&1]}}, token_metadata: true]
       string_to_quoted = &Code.string_to_quoted!(&1, opts)
@@ -646,10 +679,20 @@ defmodule Kernel.ParserTest do
                 [
                   {:->, [line: 1],
                    [
-                     [{:__block__, [token: "1", line: 1], [1]}],
+                     [
+                       {:__block__,
+                        [
+                          parens: [[line: 1, closing: [line: 1]]],
+                          token: "1",
+                          line: 1
+                        ], [1]}
+                     ],
                      {:__block__, [delimiter: "\"", line: 1], ["hello"]}
                    ]}
                 ]}
+
+      assert string_to_quoted.("(1)") ==
+               {:__block__, [parens: [[line: 1, closing: [line: 1]]], token: "1", line: 1], [1]}
     end
 
     test "adds identifier_location for qualified identifiers" do