Add :migrate_atom_interpolations option to formatter (#15531)

Author: sabiwara

lib/eex/lib/eex/engine.ex

@@ -195,7 +195,7 @@ defmodule EEx.Engine do
   def handle_expr(state, "=", ast) do
     check_state!(state)
     %{binary: binary, dynamic: dynamic, vars_count: vars_count} = state
-    var = Macro.var(:"arg#{vars_count}", __MODULE__)
+    var = Macro.var(String.to_unsafe_atom("arg#{vars_count}"), __MODULE__)
 
     ast =
       quote do

lib/elixir/lib/base.ex

@@ -436,7 +436,7 @@ defmodule Base do
   end
 
   for {base, alphabet} <- [upper: b16_alphabet, lower: to_lower_enc.(b16_alphabet)] do
-    name = :"encode16#{base}"
+    name = String.to_unsafe_atom("encode16#{base}")
     encoded = to_encode_list.(alphabet)
 
     @compile {:inline, [{name, 1}]}
@@ -617,10 +617,10 @@ defmodule Base do
   upper = Enum.with_index(b16_alphabet)
 
   for {base, alphabet} <- [upper: upper, lower: to_lower_dec.(upper), mixed: to_mixed_dec.(upper)] do
-    decode_name = :"decode16#{base}!"
-    validate_name = :"validate16#{base}?"
-    valid_char_name = :"valid_char16#{base}?"
-    valid_word_name = :"valid_word16#{base}?"
+    decode_name = String.to_unsafe_atom("decode16#{base}!")
+    validate_name = String.to_unsafe_atom("validate16#{base}?")
+    valid_char_name = String.to_unsafe_atom("valid_char16#{base}?")
+    valid_word_name = String.to_unsafe_atom("valid_word16#{base}?")
 
     {min, decoded} = to_decode_list.(alphabet)
 
@@ -735,7 +735,7 @@ defmodule Base do
   end
 
   for {base, alphabet} <- [base: b64_alphabet, url: b64url_alphabet] do
-    name = :"encode64#{base}"
+    name = String.to_unsafe_atom("encode64#{base}")
     encoded = to_encode_list.(alphabet)
 
     @compile {:inline, [{name, 1}]}
@@ -1001,12 +1001,12 @@ defmodule Base do
   end
 
   for {base, alphabet} <- [base: b64_alphabet, url: b64url_alphabet] do
-    decode_name = :"decode64#{base}!"
+    decode_name = String.to_unsafe_atom("decode64#{base}!")
 
-    validate_name = :"validate64#{base}?"
-    validate_main_name = :"validate_main64#{validate_name}?"
-    valid_char_name = :"valid_char64#{base}?"
-    valid_word_name = :"valid_word64#{base}?"
+    validate_name = String.to_unsafe_atom("validate64#{base}?")
+    validate_main_name = String.to_unsafe_atom("validate_main64#{validate_name}?")
+    valid_char_name = String.to_unsafe_atom("valid_char64#{base}?")
+    valid_word_name = String.to_unsafe_atom("valid_word64#{base}?")
     {min, decoded} = alphabet |> Enum.with_index() |> to_decode_list.()
 
     # SWAR fast path: 7 bytes per stride, validated via `valid_word64<base>?`
@@ -1314,7 +1314,7 @@ defmodule Base do
         hexupper: b32hex_alphabet,
         hexlower: to_lower_enc.(b32hex_alphabet)
       ] do
-    name = :"encode32#{base}"
+    name = String.to_unsafe_atom("encode32#{base}")
     encoded = to_encode_list.(alphabet)
 
     @compile {:inline, [{name, 1}]}
@@ -1653,16 +1653,16 @@ defmodule Base do
         hexlower: to_lower_dec.(hexupper),
         hexmixed: to_mixed_dec.(hexupper)
       ] do
-    decode_name = :"decode32#{base}!"
-    validate_name = :"validate32#{base}?"
-    validate_main_name = :"validate_main32#{validate_name}?"
-    valid_char_name = :"valid_char32#{base}?"
+    decode_name = String.to_unsafe_atom("decode32#{base}!")
+    validate_name = String.to_unsafe_atom("validate32#{base}?")
+    validate_main_name = String.to_unsafe_atom("validate_main32#{validate_name}?")
+    valid_char_name = String.to_unsafe_atom("valid_char32#{base}?")
     {min, decoded} = to_decode_list.(alphabet)
 
     # SWAR fast path: 7 bytes per stride, validated via `valid_word32<base>?`
     # in the body. Tail leftover (1-6 bytes after a 7-byte stride hits an
     # 8-byte-multiple `main`) recurses through the single-byte clause.
-    valid_word_name = :"valid_word32#{base}?"
+    valid_word_name = String.to_unsafe_atom("valid_word32#{base}?")
 
     defp unquote(validate_main_name)(<<w::56, rest::binary>>),
       do: unquote(valid_word_name)(w) and unquote(validate_main_name)(rest)

lib/elixir/lib/code.ex

@@ -767,6 +767,12 @@ defmodule Code do
     * `:migrate` (since v1.18.0) - when `true`, sets all other migration options
       to `true` by default. Defaults to `false`.
 
+    * `:migrate_atom_interpolations` (since v1.21.0) - when `true`, rewrites
+      deprecated atom interpolations to explicit calls to `String.to_unsafe_atom/1`.
+      For example, `:"foo_#{bar}"` becomes `String.to_unsafe_atom("foo_#{bar}")`.
+      Interpolated keywords like `["foo_#{bar}": 1]` are **not** migrated.
+      Defaults to the value of the `:migrate` option. This option changes the AST.
+
     * `:migrate_bitstring_modifiers` (since v1.18.0) - when `true`,
       removes unnecessary parentheses in known bitstring
       [modifiers](`<<>>/1`), for example `<<foo::binary()>>`

lib/elixir/lib/code/formatter.ex

@@ -195,6 +195,7 @@ defmodule Code.Formatter do
     file = Keyword.get(opts, :file, nil)
     sigils = Keyword.get(opts, :sigils, [])
     migrate = Keyword.get(opts, :migrate, false)
+    migrate_atom_interpolations = Keyword.get(opts, :migrate_atom_interpolations, migrate)
     migrate_bitstring_modifiers = Keyword.get(opts, :migrate_bitstring_modifiers, migrate)
     migrate_call_parens_on_pipe = Keyword.get(opts, :migrate_call_parens_on_pipe, migrate)
     migrate_charlists_as_sigils = Keyword.get(opts, :migrate_charlists_as_sigils, migrate)
@@ -223,6 +224,7 @@ defmodule Code.Formatter do
       comments: comments,
       sigils: sigils,
       file: file,
+      migrate_atom_interpolations: migrate_atom_interpolations,
       migrate_bitstring_modifiers: migrate_bitstring_modifiers,
       migrate_call_parens_on_pipe: migrate_call_parens_on_pipe,
       migrate_charlists_as_sigils: migrate_charlists_as_sigils,
@@ -334,14 +336,20 @@ defmodule Code.Formatter do
   end
 
   defp quoted_to_algebra(
-         {{:., _, [:erlang, :binary_to_atom]}, _, [{:<<>>, _, entries}, :utf8]} = quoted,
+         {{:., _, [:erlang, :binary_to_atom]}, _, [{:<<>>, _, entries} = bitstring, :utf8]} =
+           quoted,
          context,
          state
        ) do
-    if interpolated?(entries) do
-      interpolation_to_algebra(entries, @double_quote, state, ":\"", @double_quote)
-    else
-      remote_to_algebra(quoted, context, state)
+    cond do
+      not interpolated?(entries) ->
+        remote_to_algebra(quoted, context, state)
+
+      state.migrate_atom_interpolations ->
+        quoted_to_algebra(quote(do: String.to_unsafe_atom(unquote(bitstring))), context, state)
+
+      true ->
+        interpolation_to_algebra(entries, @double_quote, state, ":\"", @double_quote)
     end
   end
 

lib/elixir/lib/io/ansi.ex

@@ -159,7 +159,7 @@ defmodule IO.ANSI do
 
   for font_n <- [1, 2, 3, 4, 5, 6, 7, 8, 9] do
     @doc "Sets alternative font #{font_n}."
-    defsequence.(:"font_#{font_n}", font_n + 10, "m")
+    defsequence.(String.to_unsafe_atom("font_#{font_n}"), font_n + 10, "m")
   end
 
   @doc "Normal color or intensity."
@@ -193,13 +193,13 @@ defmodule IO.ANSI do
     defsequence.(color, code + 30, "m")
 
     @doc "Sets foreground color to light #{color}."
-    defsequence.(:"light_#{color}", code + 90, "m")
+    defsequence.(String.to_unsafe_atom("light_#{color}"), code + 90, "m")
 
     @doc "Sets background color to #{color}."
-    defsequence.(:"#{color}_background", code + 40, "m")
+    defsequence.(String.to_unsafe_atom("#{color}_background"), code + 40, "m")
 
     @doc "Sets background color to light #{color}."
-    defsequence.(:"light_#{color}_background", code + 100, "m")
+    defsequence.(String.to_unsafe_atom("light_#{color}_background"), code + 100, "m")
   end
 
   @doc "Default text color."

lib/elixir/lib/macro/env.ex

@@ -213,13 +213,13 @@ defmodule Macro.Env do
   @doc false
   @deprecated "Use Macro.Env.expand_alias/4 instead"
   def fetch_alias(%{__struct__: Macro.Env, aliases: aliases}, atom) when is_atom(atom),
-    do: Keyword.fetch(aliases, :"Elixir.#{atom}")
+    do: Keyword.fetch(aliases, String.to_unsafe_atom("Elixir.#{atom}"))
 
   @doc false
   @deprecated "Use Macro.Env.expand_alias/4 instead"
   def fetch_macro_alias(%{__struct__: Macro.Env, macro_aliases: aliases}, atom)
       when is_atom(atom),
-      do: Keyword.fetch(aliases, :"Elixir.#{atom}")
+      do: Keyword.fetch(aliases, String.to_unsafe_atom("Elixir.#{atom}"))
 
   @doc """
   Returns the modules from which the given `{name, arity}` was

lib/elixir/lib/module.ex

@@ -1192,7 +1192,7 @@ defmodule Module do
   defp expand_key(key, counters) do
     case counters do
       %{^key => count} when is_integer(count) and count >= 1 ->
-        {{:"#{key}#{count}", [], Elixir}, Map.put(counters, key, count - 1)}
+        {{String.to_unsafe_atom("#{key}#{count}"), [], Elixir}, Map.put(counters, key, count - 1)}
 
       _ ->
         {{key, [], Elixir}, counters}
@@ -1225,7 +1225,8 @@ defmodule Module do
   defp merge_signature({var, _, _} = older, {var, _, _}, _), do: older
 
   # Otherwise, returns a generic guess
-  defp merge_signature({_, meta, _}, _newer, i), do: {:"arg#{i}", meta, Elixir}
+  defp merge_signature({_, meta, _}, _newer, i),
+    do: {String.to_unsafe_atom("arg#{i}"), meta, Elixir}
 
   @doc """
   Checks if the module defines the given function or macro.

lib/elixir/test/elixir/code_formatter/migration_test.exs

@@ -10,6 +10,14 @@ defmodule Code.Formatter.MigrationTest do
 
   @short_length [line_length: 10]
 
+  describe "migrate_atom_interpolations: true" do
+    @opts [migrate_atom_interpolations: true]
+
+    test "replaces atom interpolations" do
+      assert_format ~S/:"foo_#{i}"/, ~S/String.to_unsafe_atom("foo_#{i}")/, @opts
+    end
+  end
+
   describe "migrate_bitstring_modifiers: true" do
     @opts [migrate_bitstring_modifiers: true]
 

lib/elixir/test/elixir/file/stream_test.exs

@@ -21,7 +21,8 @@ defmodule File.StreamTest do
     :erpc.call(node, File, :stream!, [src, modes, lines_or_bytes])
   end
 
-  distributed_node = :"secondary@#{node() |> Atom.to_string() |> :binary.split("@") |> tl()}"
+  distributed_node =
+    String.to_unsafe_atom("secondary@#{node() |> Atom.to_string() |> :binary.split("@") |> tl()}")
 
   for {type, node} <- [local: node(), distributed: distributed_node] do
     describe "#{type} node" do

lib/elixir/test/elixir/module/types/descr_test.exs

@@ -33,8 +33,8 @@ defmodule Module.Types.DescrTest do
       opt_difference(
         acc,
         open_map([
-          {:k, open_map([{:"value#{index}", integer()}])},
-          {:"field#{index}", integer()}
+          {:k, open_map([{String.to_unsafe_atom("value#{index}"), integer()}])},
+          {String.to_unsafe_atom("field#{index}"), integer()}
         ])
       )
     end)
@@ -45,7 +45,7 @@ defmodule Module.Types.DescrTest do
       opt_difference(
         acc,
         open_tuple([
-          open_tuple([atom([:"value#{index}"])]),
+          open_tuple([atom([String.to_unsafe_atom("value#{index}")])]),
           integer()
         ])
       )
@@ -3954,7 +3954,10 @@ defmodule Module.Types.DescrTest do
             tuple([atom([:font_style]), atom([:italic])]),
             Enum.reduce(
               for elem1 <- 1..5, elem2 <- 1..5 do
-                tuple([atom([:"f#{elem1}"]), atom([:"s#{elem2}"])])
+                tuple([
+                  atom([String.to_unsafe_atom("f#{elem1}")]),
+                  atom([String.to_unsafe_atom("s#{elem2}")])
+                ])
               end,
               &opt_union/2
             )
@@ -4008,7 +4011,7 @@ defmodule Module.Types.DescrTest do
             {:notifications, boolean()}
           ] ++
             Enum.map(1..50, fn i ->
-              {:"field_#{i}", atom([:"value_#{i}"])}
+              {String.to_unsafe_atom("field_#{i}"), atom([String.to_unsafe_atom("value_#{i}")])}
             end)
         )
 
@@ -4021,7 +4024,7 @@ defmodule Module.Types.DescrTest do
 
       expected =
         for i <- 1..50 do
-          name = :"name_#{i}"
+          name = String.to_unsafe_atom("name_#{i}")
           closed_map([__struct__: atom([name])] ++ [{name, binary()}])
         end
         |> Enum.reduce(&opt_union/2)