Do not emit invalid code when formatting assocs in maps, closes #9771

Author: josevalim

lib/elixir/lib/code/formatter.ex

@@ -2239,10 +2239,10 @@ defmodule Code.Formatter do
   defp keyword?(rest), do: rest == []
 
   defp keyword_key?({:__block__, meta, [atom]}) when is_atom(atom),
-    do: meta[:delimiter] != ":"
+    do: meta[:format] == :keyword
 
   defp keyword_key?({{:., _, [:erlang, :binary_to_atom]}, meta, [{:<<>>, _, _}, :utf8]}),
-    do: meta[:delimiter] != ":"
+    do: meta[:format] == :keyword
 
   defp keyword_key?(_),
     do: false

lib/elixir/lib/macro.ex

@@ -163,8 +163,9 @@ defmodule Macro do
       with parens. The `:closing` does not delimit the end of expression if
       there are `:do` and `:end` metadata  (when `:token_metadata` is true)
     * `:column` - the column number of the AST node (when `:columns` is true)
-    * `:delimiter` - contains the opening delimiter for sigils, strings, atoms,
-      and charlists as a string (such as `"{"`, `"/"`, `":"`, and the like)
+    * `:delimiter` - contains the opening delimiter for sigils, strings,
+      and charlists as a string (such as `"{"`, `"/"`, `"'"`, and the like)
+    * `:format` - set to `:keyword` when an atom is defined as a keyword
     * `:do` - contains metadata about the `do` location in a function call with
       `do/end` blocks (when `:token_metadata` is true)
     * `:end` - contains metadata about the `end` location in a function call with

lib/elixir/src/elixir_parser.yrl

@@ -259,9 +259,9 @@ access_expr -> bin_heredoc : build_bin_heredoc('$1').
 access_expr -> list_heredoc : build_list_heredoc('$1').
 access_expr -> bit_string : '$1'.
 access_expr -> sigil : build_sigil('$1').
-access_expr -> atom : handle_literal(?exprs('$1'), '$1', delimiter(<<$:>>)).
-access_expr -> atom_safe : build_quoted_atom('$1', true, delimiter(<<$:>>)).
-access_expr -> atom_unsafe : build_quoted_atom('$1', false, delimiter(<<$:>>)).
+access_expr -> atom : handle_literal(?exprs('$1'), '$1').
+access_expr -> atom_safe : build_quoted_atom('$1', true, []).
+access_expr -> atom_unsafe : build_quoted_atom('$1', false, []).
 access_expr -> dot_alias : '$1'.
 access_expr -> parens_call : '$1'.
 
@@ -526,12 +526,12 @@ call_args_parens -> open_paren call_args_parens_base ',' kw_base ',' close_paren
 
 % KV
 
-kw_eol -> kw_identifier : handle_literal(?exprs('$1'), '$1').
-kw_eol -> kw_identifier eol : handle_literal(?exprs('$1'), '$1').
-kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true, []).
-kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true, []).
-kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false, []).
-kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false, []).
+kw_eol -> kw_identifier : handle_literal(?exprs('$1'), '$1', [{format, keyword}]).
+kw_eol -> kw_identifier eol : handle_literal(?exprs('$1'), '$1', [{format, keyword}]).
+kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true, [{format, keyword}]).
+kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true, [{format, keyword}]).
+kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false, [{format, keyword}]).
+kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false, [{format, keyword}]).
 
 kw_base -> kw_eol container_expr : [{'$1', '$2'}].
 kw_base -> kw_base ',' kw_eol container_expr : [{'$3', '$4'} | '$1'].

lib/elixir/test/elixir/code_formatter/containers_test.exs

@@ -412,6 +412,11 @@ defmodule Code.Formatter.ContainersTest do
       assert_same map, @medium_length
     end
 
+    test "preserves user choice in regards to =>" do
+      assert_same "%{:hello => 1, :world => 2}"
+      assert_format "%{:true => 1, :false => 2}", "%{true => 1, false => 2}"
+    end
+
     test "preserves user choice even when it fits" do
       assert_same """
       %{

lib/elixir/test/elixir/code_test.exs

@@ -338,37 +338,38 @@ defmodule CodeTest do
       assert string_to_quoted.("0xEF") == {:__block__, [token: "0xEF", line: 1], [239]}
       assert string_to_quoted.("12.3") == {:__block__, [token: "12.3", line: 1], [12.3]}
       assert string_to_quoted.("nil") == {:__block__, [line: 1], [nil]}
-      assert string_to_quoted.(":one") == {:__block__, [delimiter: ":", line: 1], [:one]}
-
-      args = [[{:__block__, [token: "1", line: 1], [1]}]]
+      assert string_to_quoted.(":one") == {:__block__, [line: 1], [:one]}
+
+      assert string_to_quoted.("[one: :two]") == {
+               :__block__,
+               [{:closing, [line: 1]}, {:line, 1}],
+               [
+                 [
+                   {{:__block__, [format: :keyword, line: 1], [:one]},
+                    {:__block__, [line: 1], [:two]}}
+                 ]
+               ]
+             }
 
       assert string_to_quoted.("[1]") ==
-               {:__block__, [closing: [line: 1], line: 1], args}
-
-      args = [
-        {{:__block__, [delimiter: ":", line: 1], [:ok]},
-         {:__block__, [delimiter: ":", line: 1], [:test]}}
-      ]
-
-      assert string_to_quoted.("{:ok, :test}") ==
-               {:__block__, [closing: [line: 1], line: 1], args}
+               {:__block__, [closing: [line: 1], line: 1],
+                [[{:__block__, [token: "1", line: 1], [1]}]]}
 
       assert string_to_quoted.(~s("""\nhello\n""")) ==
                {:__block__, [delimiter: ~s["""], line: 1], ["hello\n"]}
 
       assert string_to_quoted.("'''\nhello\n'''") ==
                {:__block__, [delimiter: ~s['''], line: 1], ['hello\n']}
 
-      args = [
-        {:->, [line: 1],
-         [
-           [{:__block__, [token: "1", line: 1, closing: [line: 1], line: 1], [1]}],
-           {:__block__, [delimiter: "\"", line: 1], ["hello"]}
-         ]}
-      ]
-
       assert string_to_quoted.(~s[fn (1) -> "hello" end]) ==
-               {:fn, [closing: [line: 1], line: 1], args}
+               {:fn, [closing: [line: 1], line: 1],
+                [
+                  {:->, [line: 1],
+                   [
+                     [{:__block__, [token: "1", line: 1, closing: [line: 1], line: 1], [1]}],
+                     {:__block__, [delimiter: "\"", line: 1], ["hello"]}
+                   ]}
+                ]}
     end
 
     test "raises on bad literal" do