Not handled special case in "Expand multi-alias syntax" zipper tutorial

[jgonet]

Hey, thanks for the library, I was experimenting with zippers and so far experience is great.

I have a question/comment regarding guide about expanding aliases.
From my understanding, the do is represented Sourceror AST in two ways:

# I removed the metadata for nodes
aliases = {:__aliases__, [], [:A]}

def block(children) do
  {:__block__, [], children}
end

single_do_block = {
  block([:do]),
  block([4])
}

single_literal_module = {
  :defmodule,
  [],
  [
    aliases,
    single_do_block
  ]
}

multi_do_block = {
  block([:do]),
  block([
    block([4]),
    block([4])
  ])
}

multi_literal_module = {
  :defmodule,
  [],
  [
    aliases,
    multi_do_block
  ]
}

That is: when do block has only single child - it doesn't wrap it in the block and just stores it directly in the {do_atom, do_content} tuple representing do block.

In the tutorial we assume that we're in the block: we're adding siblings to the current node and then removing grouped alias node. This produces wrong AST when we're expanding single alias:

# removed comment handling code
defmodule AliasExpansion do
  alias Sourceror.Zipper, as: Z

  def expand_aliases(quoted) do
    Z.zip(quoted)
    |> Z.traverse(&expand_alias/1)
    |> Z.root()
  end

  defp expand_alias(
         {{:alias, _, [{{:., _, [left, :{}]}, _, right}]}, _metadata} = zipper
       ) do
    {_, _, base_segments} = left

    right
    |> Enum.map(&segments_to_alias(base_segments, &1))
    # we insert expanded aliases in reverse because insert_right doesn't move the zipper
    |> Enum.reverse()
    |> Enum.reduce(zipper, &Z.insert_right(&2, &1))
    # remove the grouped alias
    |> Z.remove()
  end

  defp expand_alias(zipper), do: zipper

  defp segments_to_alias(base_segments, {_, meta, segments}) do
    {:alias, meta, [{:__aliases__, [], base_segments ++ segments}]}
  end
end

~S"""
defmodule A do
  alias A.{B,C}
end
"""
|> Sourceror.parse_string!()
|> AliasExpansion.expand_aliases()

Output:

{:defmodule, [],
 [
   {:__aliases__, [], [:A]},
   [
     {:{}, [],
      [
        {:__block__, [], [:do]},
        {:alias, [], [{:__aliases__, [], [:A, :B]}]},
        {:alias, [], [{:__aliases__, [], [:A, :C]}]}
      ]}
   ]
 ]}

When the correct output is:

{:defmodule, [],
 [
   {:__aliases__, [], [:A]},
   [
     {
       {:__block__, [], [:do]},
       {:__block__, [],
        [
          {:alias, [], [{:__aliases__, [], [:A, :B]}]},
          {:alias, [], [{:__aliases__, [], [:A, :C]}]}
        ]}
     }
   ]
 ]}

I changed the code to replace grouped alias node to block and then inline if necessary:

defmodule AliasExpansion do
  alias Sourceror.Zipper

  def expand_aliases(quoted) do
    quoted
    |> Zipper.zip()
    |> Zipper.traverse(&expand_grouped_alias/1)
    |> Zipper.root()
  end

  defp expand_grouped_alias(
         {
           {:alias, _alias_meta, [{{:., _, [module_prefix, :{}]}, _call_meta, module_suffix}]},
           _metadata
         } = zipper
       ) do
    {:__aliases__, _meta, base_module_part} = module_prefix

    module_suffix
    |> Enum.map(&expand_alias(base_module_part, &1))
    |> Enum.reverse()
    # insert expanded aliases. insert_right doesn't move zipper, so we add them in reverse
    |> Enum.reduce(replace_with_block(zipper), &Zipper.append_child(&2, &1))
    |> inline_if_single_child()
  end

  defp expand_grouped_alias(zipper), do: zipper

  defp expand_alias(base, {:__aliases__, meta, grouped_part}) do
    full = {:__aliases__, [], base ++ grouped_part}
    {:alias, meta, [full]}
  end

  defp replace_with_block(zipper) do
    Zipper.replace(zipper, {:__block__, [trailing_comments: [], leading_comments: []], []})
  end

  defp inline_if_single_child(zipper) do
    case Zipper.children(zipper) do
      [tree] -> Zipper.replace(zipper, tree)
      _children -> zipper
    end
  end
end

alias Sourceror.Zipper

~S"""
defmodule A do
  alias A.{B, C}
end
"""
|> Sourceror.parse_string!()
|> AliasExpansion.expand_aliases()
|> Sourceror.to_string()
|> IO.puts()

EDIT: I noticed that new code doesn't merge generated blocks. This results in parens between alias groups ¯\(ツ)/¯

My question is:
Should Zipper support this special case (in Zipper.remove, insert_*, etc) or should we handle it ourselves?