wip

Author: doorgan

lib/elixir/lib/code.ex

@@ -1035,9 +1035,7 @@ defmodule Code do
     to_quoted_opts =
       [
         unescape: false,
-        literal_encoder: &{:ok, {:__block__, &2, [&1]}},
         include_comments: true,
-        token_metadata: true,
         emit_warnings: false
       ] ++ opts
 
@@ -1291,22 +1289,21 @@ defmodule Code do
 
     Process.put(:code_formatter_comments, [])
 
-    opts = 
+    opts =
       if include_comments do
-        [preserve_comments: &preserve_comments/5,
+        [
+          preserve_comments: &preserve_comments/5,
           literal_encoder: &{:ok, {:__block__, &2, [&1]}},
-      token_metadata: true,
-      unescape: false,
-      columns: true,
-] ++ opts
+          token_metadata: true,
+          unescape: false
+        ] ++ opts
       else
         opts
       end
 
     quoted = :elixir.string_to_quoted!(to_charlist(string), line, column, file, opts)
 
     if include_comments do
-      # quoted = Code.Normalizer.normalize(quoted)
       Code.Comments.merge_comments(quoted, Process.get(:code_formatter_comments))
     else
       quoted
@@ -1425,7 +1422,7 @@ defmodule Code do
   defp next_eol_count([?\r, ?\n | rest], count), do: next_eol_count(rest, count + 1)
   defp next_eol_count(_, count), do: count
 
-  defp previous_eol_count([{token, {_, _, count}} | _])
+  defp previous_eol_count([{token, {_, _, count}} | _] )
        when token in [:eol, :",", :";"] and count > 0 do
     count
   end
@@ -1492,8 +1489,17 @@ defmodule Code do
   @doc since: "1.13.0"
   @spec quoted_to_algebra(Macro.t(), keyword) :: Inspect.Algebra.t()
   def quoted_to_algebra(quoted, opts \\ []) do
+    comments = opts[:comments]
+
     quoted
     |> Code.Normalizer.normalize(opts)
+    |> then(fn quoted ->
+      if comments do
+        Code.Comments.merge_comments(quoted, comments)
+      else
+        quoted
+      end
+    end)
     |> Code.Formatter.to_algebra(opts)
   end
 

lib/elixir/lib/code/comments.ex

@@ -638,23 +638,46 @@ defmodule Code.Formatter do
     paren_fun_to_algebra(paren_fun, min_line, max_line, state)
   end
 
-  defp block_to_algebra({:__block__, meta, args}, _min_line, _max_line, state) when args in [[], [nil]] do
+  defp block_to_algebra({:__block__, meta, []}, min_line, max_line, state) do
     inner_comments = meta[:inner_comments] || []
+
     comments_docs =
       Enum.map(inner_comments, fn comment ->
         comment = format_comment(comment)
         {comment.text, @empty, 1}
       end)
 
-    docs = merge_algebra_with_comments(comments_docs, @empty)
+    comments_docs = merge_algebra_with_comments(comments_docs, @empty)
 
-    case docs do
+    case comments_docs do
       [] -> {@empty, state}
       [line] -> {line, state}
       lines -> {lines |> Enum.reduce(&line(&2, &1)) |> force_unfit(), state}
     end
   end
 
+  defp block_to_algebra({:__block__, meta, [nil]} = block, min_line, max_line, state) do
+    inner_comments = meta[:inner_comments] || []
+
+    comments_docs =
+      Enum.map(inner_comments, fn comment ->
+        comment = format_comment(comment)
+        {comment.text, @empty, 1}
+      end)
+
+    comments_docs = merge_algebra_with_comments(comments_docs, @empty)
+
+    {doc, state} = block_args_to_algebra([block], min_line, max_line, state)
+
+    docs = case comments_docs do
+      [] -> doc
+      [line] -> line(doc, line)
+      lines -> doc |> line(lines |> Enum.reduce(&line(&2, &1)) |> force_unfit())
+    end
+
+    {docs, state}
+  end
+
   defp block_to_algebra({:__block__, _, [_, _ | _] = args}, min_line, max_line, state) do
     block_args_to_algebra(args, min_line, max_line, state)
   end
@@ -1822,25 +1845,26 @@ defmodule Code.Formatter do
       {{doc, @empty, 1}, state}
     end
 
-    # If skipping parens, we cannot extract the comments of the first
-    # argument as there is no place to move them to, so we handle it now.
+    inner_comments = List.wrap(meta[:inner_comments])
+    comments_doc =
+      Enum.map(inner_comments, fn comment ->
+        comment = format_comment(comment)
+        {comment.text, @empty, 1}
+      end)
+
+    join = if args == [] and inner_comments != [], do: :line, else: join
+
     {args, acc, state} =
       case args do
-        [head | tail] when skip_parens? ->
-          {doc_triplet, state} = arg_to_algebra.(head, tail, state)
-          {tail, [doc_triplet], state}
+        [] ->
+          {args, comments_doc, state}
 
-        _ ->
+        [_ | _] ->
           {args, [], state}
       end
 
     {args_docs, comments?, state} =
-      case args do
-        [] ->
-          quoted_to_algebra_with_comments(args, acc, min_line, max_line, state, arg_to_algebra)
-        _ ->
-          quoted_to_algebra_with_comments(args, acc, min_line, max_line, state, arg_to_algebra)
-      end
+      quoted_to_algebra_with_comments(args, acc, min_line, max_line, state, arg_to_algebra)
 
     cond do
       args_docs == [] ->
@@ -1881,6 +1905,22 @@ defmodule Code.Formatter do
       |> maybe_force_clauses(clauses, state)
       |> group()
 
+    leading_comments = meta[:leading_comments] || []
+
+    comments =
+      Enum.map(leading_comments, fn comment ->
+        comment = format_comment(comment)
+        {comment.text, @empty, 1}
+      end)
+
+    comments = merge_algebra_with_comments(comments, @empty)
+
+    # If there are any comments before the ->, we hoist them up above the fn
+    doc = case comments do
+      [] -> doc
+      [comments] -> line(comments, doc)
+    end
+
     {doc, state}
   end
 
@@ -2115,36 +2155,63 @@ defmodule Code.Formatter do
   end
 
   defp each_quoted_to_algebra_with_comments([arg | args], acc, state, fun, comments?) do
-    {doc_triplet, state} = fun.(arg, args, state)
-
-
     case traverse_line(arg, {@max_line, @min_line}) do
       {@max_line, @min_line} ->
+        {doc_triplet, state} = fun.(arg, args, state)
         acc = [doc_triplet | acc]
         each_quoted_to_algebra_with_comments(args, acc, state, fun, comments?)
 
       {doc_start, doc_end} ->
-        {leading_comments, trailing_comments} =
+        {leading_comments, trailing_comments, arg} =
           case arg do
+            [{_, _, _} | _] = items ->
+              {leading_comments, trailing_comments} =
+                Enum.reduce(items, {[], []}, fn {_, meta, _}, {leading_comments, trailing_comments} ->
+                  item_leading_comments = meta[:leading_comments] || []
+                  item_trailing_comments = meta[:trailing_comments] || []
+
+                  {leading_comments ++ item_leading_comments, trailing_comments ++ item_trailing_comments}
+                end)
+
+              {leading_comments, trailing_comments, arg}
+
+            {{_, meta, _}, index} when is_integer(index) ->
+              leading_comments = meta[:leading_comments] || []
+              trailing_comments = meta[:trailing_comments] || []
+              {leading_comments, trailing_comments, arg}
+
+            {:<<>>, _, _} ->
+              extract_interpolation_comments(arg)
+
+            {{:., _, [List, :to_charlist]}, _, _} ->
+              extract_interpolation_comments(arg)
+
             {_, meta, _} ->
               leading_comments = meta[:leading_comments] || []
               trailing_comments = meta[:trailing_comments] || []
-              {leading_comments, trailing_comments}
+              {leading_comments, trailing_comments, arg}
 
             {{_, left_meta, _}, {_, right_meta, _}} ->
               leading_comments = left_meta[:leading_comments] || []
               trailing_comments = right_meta[:trailing_comments] || []
 
-              {leading_comments, trailing_comments}
+              {leading_comments, trailing_comments, arg}
+            {{_, context}, {_, meta, _}} when context in [:left, :right, :operand, :parens_arg] ->
+              leading_comments = meta[:leading_comments] || []
+              trailing_comments = meta[:trailing_comments] || []
+
+              {leading_comments, trailing_comments, arg}
             _ ->
-              {[], []}
+              {[], [], arg}
           end
 
         comments? = leading_comments != [] or trailing_comments != []
 
         leading_docs = build_leading_comments([], leading_comments, doc_start)
         trailing_docs = build_trailing_comments([], trailing_comments)
 
+        {doc_triplet, state} = fun.(arg, args, state)
+
         doc_triplet = adjust_trailing_newlines(doc_triplet, doc_end, trailing_comments)
 
         acc = Enum.concat([trailing_docs, [doc_triplet], leading_docs, acc])
@@ -2153,6 +2220,114 @@ defmodule Code.Formatter do
     end
   end
 
+  defp extract_interpolation_comments({:<<>>, meta, entries} = quoted) when is_list(entries) do
+    node_leading = List.wrap(meta[:leading_comments])
+    node_trailing = List.wrap(meta[:trailing_comments])
+
+    if interpolated?(entries) do
+      {entries, comments} =
+        Macro.postwalk(entries, [], fn
+          {form, meta, args}, acc ->
+            leading = List.wrap(meta[:leading_comments])
+            trailing = List.wrap(meta[:trailing_comments])
+
+            acc = Enum.concat([leading, trailing, acc])
+            meta = Keyword.drop(meta, [:leading_comments, :trailing_comments])
+            quoted = {form, meta, args}
+
+            {quoted, acc}
+
+          quoted, acc ->
+            {quoted, acc}
+        end)
+
+      quoted = {:<<>>, meta, entries}
+
+      comments = Enum.sort_by(comments, & &1.line)
+
+      last_value =
+        for {:"::", _, [{_, _, [last_value]}, _]} <- entries, reduce: nil do
+          _ -> last_value
+        end
+
+      {_, last_node_line} =
+        Macro.postwalk(last_value, 0, fn
+          {_, meta, _} = quoted, max_seen ->
+            line = meta[:line] || max_seen
+
+            {quoted, max(max_seen, line)}
+
+          quoted, max_seen ->
+            {quoted, max_seen}
+        end)
+
+      {leading, trailing} =
+        Enum.split_with(comments, fn comment ->
+          comment.line <= last_node_line
+        end)
+
+      {node_leading ++ leading, node_trailing ++ trailing, quoted}
+
+    else
+      {node_leading, node_trailing, quoted}
+    end
+  end
+
+  defp extract_interpolation_comments({{:., _, [List, :to_charlist]} = dot, meta, [entries]} = quoted) when is_list(entries) do
+    node_leading = List.wrap(meta[:leading_comments])
+    node_trailing = List.wrap(meta[:trailing_comments])
+
+    if meta[:delimiter] do
+      {entries, comments} =
+        Macro.postwalk(entries, [], fn
+          {form, meta, args}, acc ->
+            leading = List.wrap(meta[:leading_comments])
+            trailing = List.wrap(meta[:trailing_comments])
+
+            acc = Enum.concat([leading, trailing, acc])
+            meta = Keyword.drop(meta, [:leading_comments, :trailing_comments])
+            quoted = {form, meta, args}
+
+            {quoted, acc}
+
+          quoted, acc ->
+            {quoted, acc}
+        end)
+
+      quoted = {dot, meta, [entries]}
+
+      comments = Enum.sort_by(comments, & &1.line)
+
+      last_value =
+        for {{:., _, [Kernel, :to_string]}, _, [last_value]} <- entries, reduce: nil do
+          _ -> last_value
+        end
+
+      {_, last_node_line} =
+        Macro.postwalk(last_value, 0, fn
+          {_, meta, _} = quoted, max_seen ->
+            line = meta[:line] || max_seen
+
+            {quoted, max(max_seen, line)}
+
+          quoted, max_seen ->
+            {quoted, max_seen}
+        end)
+
+      {leading, trailing} =
+        Enum.split_with(comments, fn comment ->
+          comment.line <= last_node_line
+        end)
+
+      {node_leading ++ leading, node_trailing ++ trailing, quoted}
+
+    else
+      {node_leading, node_trailing, quoted}
+    end
+  end
+
+  defp extract_interpolation_comments(quoted), do: {[], [], quoted}
+
   defp build_leading_comments(acc, [], _), do: acc
 
   defp build_leading_comments(acc, [comment | rest], doc_start) do
@@ -2165,16 +2340,18 @@ defmodule Code.Formatter do
     build_leading_comments(acc, rest, doc_start)
   end
 
-  defp add_previous_to_acc([{doc, next_line, newlines} | acc], previous) when newlines < previous,
-    do: [{doc, next_line, previous} | acc]
+  defp add_previous_to_acc([{doc, next_line, newlines} | acc], previous) when newlines < previous do
+    IO.inspect({doc, next_line, newlines, previous})
+    [{doc, next_line, previous} | acc]
+  end
 
   defp add_previous_to_acc(acc, _previous),
     do: acc
   defp build_trailing_comments(acc, []), do: acc
 
   defp build_trailing_comments(acc, [comment | rest]) do
     comment = format_comment(comment)
-    %{previous_eol_count: previous, next_eol_count: next, text: doc} = comment
+    %{next_eol_count: next, text: doc} = comment
     acc = [{doc, @empty, next} | acc]
     build_trailing_comments(acc, rest)
   end
@@ -2186,6 +2363,11 @@ defmodule Code.Formatter do
     {doc, next_line, 1}
   end
 
+  defp adjust_trailing_newlines({doc, next_line, newlines}, doc_end, [%{line: line, previous_eol_count: previous} | _])
+       when newlines == 1 and line > doc_end + 1 do
+    {doc, next_line, 2}
+  end
+
   defp adjust_trailing_newlines(doc_triplet, _, _), do: doc_triplet
 
 
@@ -2391,11 +2573,12 @@ defmodule Code.Formatter do
     false
   end
 
-  defp eol_or_comments?(meta, %{comments: comments} = state) do
+  defp eol_or_comments?(meta, state) do
     eol?(meta, state) or
       (
         min_line = line(meta)
         max_line = closing_line(meta)
+        comments = meta[:trailing_comments] || []
         Enum.any?(comments, fn %{line: line} -> line > min_line and line < max_line end)
       )
   end

lib/elixir/lib/code/formatter.ex

@@ -210,6 +210,7 @@ defmodule Code.AstCommentsTest do
         #trailing 3
         ] # trailing outside
         """)
+        |> IO.inspect()
 
       assert {:__block__, list_meta,
               [
@@ -647,5 +648,28 @@ defmodule Code.AstCommentsTest do
 
       assert [%{line: 10, text: "# after body"}] = world_meta[:trailing_comments]
     end
+
+    test "merges leading comments into the stab if left side is empty" do
+      quoted =
+        parse_string!("""
+        fn
+          # leading
+          ->
+          hello
+          hello
+        end
+        """)
+
+      assert {:fn, _,
+              [
+                {:->, stab_meta,
+                 [
+                   [],
+                   _
+                 ]}
+              ]} = quoted
+
+      assert [%{line: 2, text: "# leading"}] = stab_meta[:leading_comments]
+    end
   end
 end

lib/elixir/test/elixir/code/ast_comments_test.exs

@@ -3,519 +3,29 @@ Code.require_file("../test_helper.exs", __DIR__)
 defmodule Code.Formatter.AstCommentsTest do
   use ExUnit.Case, async: true
 
-  def parse_string!(string) do
-    Code.string_to_quoted!(string, include_comments: true)
-  end
-
-  describe "merge_comments/2" do
-    test "merges comments in empty AST" do
-      quoted =
-        parse_string!("""
-        # some comment
-        # another comment
-        """)
-
-      assert {:__block__, meta, []} = quoted
-
-      assert [%{line: 1, text: "# some comment"}, %{line: 2, text: "# another comment"}] =
-               meta[:inner_comments]
-    end
-
-    test "merges leading comments in assorted terms" do
-      quoted =
-        parse_string!("""
-        # leading var
-        var
-        # trailing var
-        """)
-
-      assert {:var, meta, _} = quoted
-
-      assert [%{line: 1, text: "# leading var"}] = meta[:leading_comments]
-      assert [%{line: 3, text: "# trailing var"}] = meta[:trailing_comments]
-
-      quoted =
-        parse_string!("""
-        # leading 1
-        1
-        # trailing 1
-        """)
-
-      assert {:__block__, one_meta, [1]} = quoted
-
-      assert [%{line: 1, text: "# leading 1"}] = one_meta[:leading_comments]
-      assert [%{line: 3, text: "# trailing 1"}] = one_meta[:trailing_comments]
-
-      quoted =
-        parse_string!("""
-        # leading qualified call
-        Foo.bar(baz)
-        # trailing qualified call
-        """)
-
-      assert {{:., _, [_Foo, _bar]}, meta, _} = quoted
-
-      assert [%{line: 1, text: "# leading qualified call"}] = meta[:leading_comments]
-      assert [%{line: 3, text: "# trailing qualified call"}] = meta[:trailing_comments]
-
-      quoted =
-        parse_string!("""
-        # leading qualified call
-        Foo.
-          # leading bar
-          bar(baz)
-        # trailing qualified call
-        """)
-
-      assert {{:., _, [_Foo, _]}, meta,
-              [
-                {:baz, _, _}
-              ]} = quoted
-
-      assert [%{line: 1, text: "# leading qualified call"}, %{line: 3, text: "# leading bar"}] =
-               meta[:leading_comments]
-
-      assert [%{line: 5, text: "# trailing qualified call"}] = meta[:trailing_comments]
-    end
-
-    # Do/end blocks
-
-    test "merges comments in do/end block" do
-      quoted =
-        parse_string!("""
-        def a do
-          foo()
-          :ok
-          # A
-        end # B
-        """)
-
-      assert {:def, def_meta,
-              [
-                {:a, _, _},
-                [
-                  {{:__block__, _, [:do]},
-                   {:__block__, _,
-                    [
-                      {:foo, _, _},
-                      {:__block__, meta, [:ok]}
-                    ]}}
-                ]
-              ]} =
-               quoted
-
-      assert [%{line: 4, text: "# A"}] = meta[:trailing_comments]
-
-      assert [%{line: 5, text: "# B"}] = def_meta[:trailing_comments]
-    end
-
-    test "merges comments for named do/end blocks" do
-      quoted =
-        parse_string!("""
-        def a do
-          # leading var1
-          var1
-          # trailing var1
-        else
-          # leading var2
-          var2
-          # trailing var2
-        catch
-          # leading var3
-          var3
-          # trailing var3
-        rescue
-          # leading var4
-          var4
-          # trailing var4
-        after
-          # leading var5
-          var5
-          # trailing var5
-        end
-        """)
-
-      assert {:def, _,
-              [
-                {:a, _, _},
-                [
-                  {{:__block__, _, [:do]}, {:var1, var1_meta, _}},
-                  {{:__block__, _, [:else]}, {:var2, var2_meta, _}},
-                  {{:__block__, _, [:catch]}, {:var3, var3_meta, _}},
-                  {{:__block__, _, [:rescue]}, {:var4, var4_meta, _}},
-                  {{:__block__, _, [:after]}, {:var5, var5_meta, _}}
-                ]
-              ]} =
-               quoted
-
-      assert [%{line: 2, text: "# leading var1"}] = var1_meta[:leading_comments]
-      assert [%{line: 4, text: "# trailing var1"}] = var1_meta[:trailing_comments]
-      assert [%{line: 6, text: "# leading var2"}] = var2_meta[:leading_comments]
-      assert [%{line: 8, text: "# trailing var2"}] = var2_meta[:trailing_comments]
-      assert [%{line: 10, text: "# leading var3"}] = var3_meta[:leading_comments]
-      assert [%{line: 12, text: "# trailing var3"}] = var3_meta[:trailing_comments]
-      assert [%{line: 14, text: "# leading var4"}] = var4_meta[:leading_comments]
-      assert [%{line: 16, text: "# trailing var4"}] = var4_meta[:trailing_comments]
-      assert [%{line: 18, text: "# leading var5"}] = var5_meta[:leading_comments]
-      assert [%{line: 20, text: "# trailing var5"}] = var5_meta[:trailing_comments]
-    end
-
-    test "merges inner comments for empty named do/end blocks" do
-      quoted =
-        parse_string!("""
-        def a do
-          # inside do
-        else
-          # inside else
-        catch
-          # inside catch
-        rescue
-          # inside rescue
-        after
-          # inside after
-        end
-        """)
-
-      assert {:def, _,
-              [
-                {:a, _, _},
-                [
-                  {{:__block__, _, [:do]}, {:__block__, do_meta, _}},
-                  {{:__block__, _, [:else]}, {:__block__, else_meta, _}},
-                  {{:__block__, _, [:catch]}, {:__block__, catch_meta, _}},
-                  {{:__block__, _, [:rescue]}, {:__block__, rescue_meta, _}},
-                  {{:__block__, _, [:after]}, {:__block__, after_meta, _}}
-                ]
-              ]} =
-               quoted
-
-      assert [%{line: 2, text: "# inside do"}] = do_meta[:inner_comments]
-      assert [%{line: 4, text: "# inside else"}] = else_meta[:inner_comments]
-      assert [%{line: 6, text: "# inside catch"}] = catch_meta[:inner_comments]
-      assert [%{line: 8, text: "# inside rescue"}] = rescue_meta[:inner_comments]
-      assert [%{line: 10, text: "# inside after"}] = after_meta[:inner_comments]
-    end
-
-    # Lists
-
-    test "merges comments in list" do
-      quoted =
-        parse_string!("""
-        [
-        #leading 1
-        1,
-        #leading 2
-        2,
-        3
-        #trailing 3
-        ] # trailing outside
-        """)
-
-      assert {:__block__, list_meta,
-              [
-                [
-                  {:__block__, one_meta, [1]},
-                  {:__block__, two_meta, [2]},
-                  {:__block__, three_meta, [3]}
-                ]
-              ]} = quoted
-
-      assert [%{line: 2, text: "#leading 1"}] = one_meta[:leading_comments]
-      assert [%{line: 4, text: "#leading 2"}] = two_meta[:leading_comments]
-      assert [%{line: 7, text: "#trailing 3"}] = three_meta[:trailing_comments]
-      assert [%{line: 8, text: "# trailing outside"}] = list_meta[:trailing_comments]
-    end
-
-    test "merges inner comments in empty list" do
-      quoted =
-        parse_string!("""
-        [
-        # inner 1
-        # inner 2
-        ] # trailing outside
-        """)
-
-      assert {:__block__, list_meta, [[]]} = quoted
-
-      assert [%{line: 2, text: "# inner 1"}, %{line: 3, text: "# inner 2"}] =
-               list_meta[:inner_comments]
-
-      assert [%{line: 4, text: "# trailing outside"}] = list_meta[:trailing_comments]
-    end
+  @string ~S"""
+    case decomposition do
+      # Decomposition
+      <<h, _::binary>> when h != ?< ->
+        decomposition =
+          decomposition
+          |> :binary.split(" ", [:global])
+          |> Enum.map(&String.to_integer(&1, 16))
 
-    # Keyword lists
+        Map.put(dacc, String.to_integer(codepoint, 16), decomposition)
 
-    test "merges comments in keyword list" do
-      quoted =
-        parse_string!("""
-        [
-        #leading a
-        a: 1,
-        #leading b
-        b: 2,
-        c: 3
-        #trailing 3
-        ] # trailing outside
-        """)
-
-      assert {:__block__, keyword_list_meta,
-              [
-                [
-                  {
-                    {:__block__, a_key_meta, [:a]},
-                    {:__block__, _, [1]}
-                  },
-                  {
-                    {:__block__, b_key_meta, [:b]},
-                    {:__block__, _, [2]}
-                  },
-                  {
-                    {:__block__, _, [:c]},
-                    {:__block__, c_value_meta, [3]}
-                  }
-                ]
-              ]} = quoted
-
-      assert [%{line: 2, text: "#leading a"}] = a_key_meta[:leading_comments]
-      assert [%{line: 4, text: "#leading b"}] = b_key_meta[:leading_comments]
-      assert [%{line: 7, text: "#trailing 3"}] = c_value_meta[:trailing_comments]
-      assert [%{line: 8, text: "# trailing outside"}] = keyword_list_meta[:trailing_comments]
-    end
-
-    test "merges comments in partial keyword list" do
-      quoted =
-        parse_string!("""
-        [
-        #leading 1
-        1,
-        #leading b
-        b: 2
-        #trailing b
-        ] # trailing outside
-        """)
-
-      assert {:__block__, keyword_list_meta,
-              [
-                [
-                  {:__block__, one_key_meta, [1]},
-                  {
-                    {:__block__, b_key_meta, [:b]},
-                    {:__block__, b_value_meta, [2]}
-                  }
-                ]
-              ]} = quoted
-
-      assert [%{line: 2, text: "#leading 1"}] = one_key_meta[:leading_comments]
-      assert [%{line: 4, text: "#leading b"}] = b_key_meta[:leading_comments]
-      assert [%{line: 6, text: "#trailing b"}] = b_value_meta[:trailing_comments]
-      assert [%{line: 7, text: "# trailing outside"}] = keyword_list_meta[:trailing_comments]
-    end
-
-    # Tuples
-
-    test "merges comments in n-tuple" do
-      quoted =
-        parse_string!("""
-        {
-        #leading 1
-        1,
-        #leading 2
-        2,
-        3
-        #trailing 3
-        } # trailing outside
-        """)
-
-      assert {:{}, tuple_meta,
-              [
-                {:__block__, one_meta, [1]},
-                {:__block__, two_meta, [2]},
-                {:__block__, three_meta, [3]}
-              ]} = quoted
-
-      assert [%{line: 2, text: "#leading 1"}] = one_meta[:leading_comments]
-      assert [%{line: 4, text: "#leading 2"}] = two_meta[:leading_comments]
-      assert [%{line: 7, text: "#trailing 3"}] = three_meta[:trailing_comments]
-      assert [%{line: 8, text: "# trailing outside"}] = tuple_meta[:trailing_comments]
+      _ ->
+        dacc
     end
+  """
 
-    test "merges comments in 2-tuple" do
-      quoted =
-        parse_string!("""
-        {
-          #leading 1
-          1,
-          #leading 2
-          2
-          #trailing 2
-        } # trailing outside
-        """)
-
-      assert {:__block__, tuple_meta,
-              [
-                {
-                  {:__block__, one_meta, [1]},
-                  {:__block__, two_meta, [2]}
-                }
-              ]} = quoted
-
-      assert [%{line: 2, text: "#leading 1"}] = one_meta[:leading_comments]
-      assert [%{line: 4, text: "#leading 2"}] = two_meta[:leading_comments]
-      assert [%{line: 6, text: "#trailing 2"}] = two_meta[:trailing_comments]
-      assert [%{line: 7, text: "# trailing outside"}] = tuple_meta[:trailing_comments]
-    end
-
-    test "merges inner comments in empty tuple" do
-      quoted =
-        parse_string!("""
-        {
-        # inner 1
-        # inner 2
-        } # trailing outside
-        """)
-
-      assert {:{}, tuple_meta, []} = quoted
-
-      assert [%{line: 2, text: "# inner 1"}, %{line: 3, text: "# inner 2"}] =
-               tuple_meta[:inner_comments]
-
-      assert [%{line: 4, text: "# trailing outside"}] = tuple_meta[:trailing_comments]
-    end
-
-    # Maps
-
-    test "merges comments in maps" do
-      quoted =
-        parse_string!("""
-        %{
-        #leading 1
-        1 => 1,
-        #leading 2
-        2 => 2,
-        3 => 3
-        #trailing 3
-        } # trailing outside
-        """)
-
-      assert {:%{}, map_meta,
-              [
-                {
-                  {:__block__, one_key_meta, [1]},
-                  {:__block__, _, [1]}
-                },
-                {
-                  {:__block__, two_key_meta, [2]},
-                  {:__block__, _, [2]}
-                },
-                {
-                  {:__block__, _, [3]},
-                  {:__block__, three_value_meta, [3]}
-                }
-              ]} = quoted
-
-      assert [%{line: 2, text: "#leading 1"}] = one_key_meta[:leading_comments]
-      assert [%{line: 4, text: "#leading 2"}] = two_key_meta[:leading_comments]
-      assert [%{line: 7, text: "#trailing 3"}] = three_value_meta[:trailing_comments]
-      assert [%{line: 8, text: "# trailing outside"}] = map_meta[:trailing_comments]
-    end
-
-    test "merges inner comments in empty maps" do
-      quoted =
-        parse_string!("""
-        %{
-        # inner 1
-        # inner 2
-        } # trailing outside
-        """)
-
-      assert {:%{}, map_meta, []} = quoted
-
-      assert [%{line: 2, text: "# inner 1"}, %{line: 3, text: "# inner 2"}] =
-               map_meta[:inner_comments]
-
-      assert [%{line: 4, text: "# trailing outside"}] = map_meta[:trailing_comments]
-    end
+  test "wip" do
+    Code.format_string!(@string)
+    |> IO.puts()
   end
 
-  test "handles the presence of unquote_splicing" do
-    quoted =
-      parse_string!("""
-      %{
-        # leading baz
-        :baz => :bat,
-        :quux => :quuz,
-        # leading unquote splicing
-        unquote_splicing(foo: :bar)
-        # trailing unquote splicing
-      }
-      """)
-
-    assert {:%{}, _,
-            [
-              {{:__block__, baz_key_meta, [:baz]}, {:__block__, _, [:bat]}},
-              {{:__block__, _, [:quux]}, {:__block__, _, [:quuz]}},
-              {:unquote_splicing, unquote_splicing_meta, _}
-            ]} = quoted
-
-    assert [%{line: 2, text: "# leading baz"}] = baz_key_meta[:leading_comments]
-
-    assert [%{line: 5, text: "# leading unquote splicing"}] =
-             unquote_splicing_meta[:leading_comments]
-
-    assert [%{line: 7, text: "# trailing unquote splicing"}] =
-             unquote_splicing_meta[:trailing_comments]
-  end
-
-  # Structs
-
-  test "merges comments in structs" do
-    quoted =
-      parse_string!("""
-      %SomeStruct{
-      #leading 1
-      a: 1,
-      #leading 2
-      b: 2,
-      c: 3
-      #trailing 3
-      } # trailing outside
-      """)
-
-    assert {:%, struct_meta,
-            [
-              {:__aliases__, _, [:SomeStruct]},
-              {:%{}, _,
-               [
-                 {{:__block__, a_key_meta, [:a]}, {:__block__, _, [1]}},
-                 {{:__block__, b_key_meta, [:b]}, {:__block__, _, [2]}},
-                 {{:__block__, _, [:c]}, {:__block__, c_value_meta, [3]}}
-               ]}
-            ]} = quoted
-
-    assert [%{line: 2, text: "#leading 1"}] = a_key_meta[:leading_comments]
-    assert [%{line: 4, text: "#leading 2"}] = b_key_meta[:leading_comments]
-    assert [%{line: 7, text: "#trailing 3"}] = c_value_meta[:trailing_comments]
-    assert [%{line: 8, text: "# trailing outside"}] = struct_meta[:trailing_comments]
-  end
-
-  test "merges inner comments in structs" do
-    quoted =
-      parse_string!("""
-      %SomeStruct{
-      # inner 1
-      # inner 2
-      } # trailing outside
-      """)
-
-    assert {:%, struct_meta,
-            [
-              {:__aliases__, _, [:SomeStruct]},
-              {:%{}, args_meta, []}
-            ]} = quoted
-
-    assert [%{line: 2, text: "# inner 1"}, %{line: 3, text: "# inner 2"}] =
-             args_meta[:inner_comments]
-
-    assert [%{line: 4, text: "# trailing outside"}] = struct_meta[:trailing_comments]
+  test "test" do
+    Code.string_to_quoted!(@string, include_comments: true, unescape: false)
+    # |> IO.inspect()
   end
 end