Handle false positive on List.to_charlist/1 formatting, closes #12248

Author: josevalim

lib/elixir/lib/code/normalizer.ex

@@ -70,15 +70,15 @@ defmodule Code.Normalizer do
   # Atoms with interpolations
   defp do_normalize(
          {{:., dot_meta, [:erlang, :binary_to_atom]}, call_meta,
-          [{:<<>>, _, args} = string, :utf8]},
+          [{:<<>>, _, parts} = string, :utf8]},
          state
        )
-       when is_list(args) do
+       when is_list(parts) do
     dot_meta = patch_meta_line(dot_meta, state.parent_meta)
     call_meta = patch_meta_line(call_meta, dot_meta)
 
     utf8 =
-      if args == [] or interpolated?(string) do
+      if parts == [] or binary_interpolated?(parts) do
         # a non-normalized :utf8 atom signals an atom interpolation
         :utf8
       else
@@ -96,23 +96,27 @@ defmodule Code.Normalizer do
   end
 
   # Charlists with interpolations
-  defp do_normalize({{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]}, state) do
-    parts =
-      Enum.map(parts, fn
-        {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args} ->
-          args = normalize_args(args, state)
-
-          {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args}
-
-        part ->
-          if state.escape do
-            maybe_escape_literal(part, state)
-          else
-            part
-          end
-      end)
+  defp do_normalize({{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]} = quoted, state) do
+    if list_interpolated?(parts) do
+      parts =
+        Enum.map(parts, fn
+          {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args} ->
+            args = normalize_args(args, state)
+
+            {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args}
+
+          part when is_binary(part) ->
+            if state.escape do
+              maybe_escape_literal(part, state)
+            else
+              part
+            end
+        end)
 
-    {{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]}
+      {{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]}
+    else
+      normalize_call(quoted, state)
+    end
   end
 
   # Don't normalize the `Access` atom in access syntax
@@ -389,11 +393,11 @@ defmodule Code.Normalizer do
   defp allow_keyword?(:{}, _), do: false
   defp allow_keyword?(op, arity), do: not is_atom(op) or not Macro.operator?(op, arity)
 
-  defp normalize_bitstring({:<<>>, meta, parts} = quoted, state, escape_interpolation \\ false) do
+  defp normalize_bitstring({:<<>>, meta, parts}, state, escape_interpolation \\ false) do
     meta = patch_meta_line(meta, state.parent_meta)
 
     parts =
-      if interpolated?(quoted) do
+      if binary_interpolated?(parts) do
         normalize_interpolation_parts(parts, %{state | parent_meta: meta}, escape_interpolation)
       else
         state = %{state | parent_meta: meta}
@@ -543,17 +547,20 @@ defmodule Code.Normalizer do
     term
   end
 
-  # Check if we have an interpolated string.
-  defp interpolated?({:<<>>, _, [_ | _] = parts}) do
+  defp binary_interpolated?(parts) do
     Enum.all?(parts, fn
       {:"::", _, [{{:., _, [Kernel, :to_string]}, _, [_]}, {:binary, _, _}]} -> true
       binary when is_binary(binary) -> true
       _ -> false
     end)
   end
 
-  defp interpolated?(_) do
-    false
+  defp list_interpolated?(parts) do
+    Enum.all?(parts, fn
+      {{:., _, [Kernel, :to_string]}, _, [_]} -> true
+      binary when is_binary(binary) -> true
+      _ -> false
+    end)
   end
 
   defp patch_meta_line(meta, parent_meta) do

lib/elixir/test/elixir/code_normalizer/quoted_ast_test.exs

@@ -515,6 +515,17 @@ defmodule Code.Normalizer.QuotedASTTest do
     test "charlist" do
       assert quoted_to_string(quote(do: [])) == "[]"
       assert quoted_to_string(quote(do: 'abc')) == "'abc'"
+
+      # False positive
+      assert quoted_to_string(
+               quote do
+                 :"Elixir.List".to_charlist([
+                   case var do
+                     var -> var
+                   end
+                 ])
+               end
+             ) =~ "List.to_charlist([\n  case var do\n    var -> var\n  end\n])"
     end
 
     test "string" do