Dont add [] for last arg keyword lists in tuples, lists and when/2

Author: ericmj

lib/elixir/lib/macro.ex

@@ -49,8 +49,8 @@ defmodule Macro do
   end
 
   @doc """
-  Breaks a pipeline expression into a list. 
-  
+  Breaks a pipeline expression into a list.
+
   Raises if the pipeline is ill-formed.
   """
   @spec unpipe(Macro.t) :: [Macro.t]
@@ -152,8 +152,8 @@ defmodule Macro do
   end
 
   @doc %S"""
-  Unescape the given chars. 
-  
+  Unescape the given chars.
+
   This is the unescaping behavior
   used by default in Elixir single- and double-quoted strings.
   Check `unescape_string/2` for information on how to customize
@@ -298,7 +298,14 @@ defmodule Macro do
 
   # Tuple containers
   def to_string({ :{}, _, args } = ast, fun) do
-    fun.(ast, "{" <> Enum.map_join(args, ", ", &to_string(&1, fun)) <> "}")
+    if match?([_], args) do
+      tuple = "{" <> Enum.map_join(args, ", ", &to_string(&1, fun)) <> "}"
+    else
+      args = args_to_string(args, fun)
+      tuple = "{" <> args <> "}"
+    end
+
+    fun.(ast, tuple)
   end
 
   # Fn keyword
@@ -321,6 +328,17 @@ defmodule Macro do
     fun.(ast, "(" <> arrow_to_string(ast, fun, true) <> ")")
   end
 
+  # left when right
+  def to_string({ :when, _, [left, right] } = ast, fun) do
+    if right != [] and Keyword.keyword?(right) do
+      right = kw_list_to_string(right, fun)
+    else
+      right = fun.(ast, op_to_string(right, fun, :when, :right))
+    end
+
+    fun.(ast, op_to_string(left, fun, :when, :left) <> " when " <> right)
+  end
+
   # Binary ops
   def to_string({ op, _, [left, right] } = ast, fun) when op in @binary_ops do
     fun.(ast, op_to_string(left, fun, op, :left) <> " #{op} " <> op_to_string(right, fun, op, :right))
@@ -362,11 +380,15 @@ defmodule Macro do
 
   # Lists
   def to_string(list, fun) when is_list(list) do
-    if Keyword.keyword?(list) do
-      fun.(list, "[" <> kw_list_to_string(list, fun) <> "]")
-    else
-      fun.(list, "[" <> Enum.map_join(list, ", ", &to_string(&1, fun)) <> "]")
-    end
+    fun.(list, cond do
+      Keyword.keyword?(list) ->
+        "[" <> kw_list_to_string(list, fun) <> "]"
+      not match?([_], list) ->
+        args = args_to_string(list, fun)
+        "[" <> args <> "]"
+      true ->
+        "[" <> Enum.map_join(list, ", ", &to_string(&1, fun)) <> "]"
+    end)
   end
 
   # All other structures
@@ -389,18 +411,20 @@ defmodule Macro do
   defp call_to_string(other, fun),                    do: to_string(other, fun)
 
   defp call_to_string_with_args(target, args, fun) do
-    { list, last } = :elixir_utils.split_last(args)
     target = call_to_string(target, fun)
+    args = args_to_string(args, fun)
+    target <> "(" <> args <> ")"
+  end
 
-    case last != [] and Keyword.keyword?(last) do
-      true  ->
-        args = Enum.map_join(list, ", ", &to_string(&1, fun))
-        if list != [], do: args = args <> ", "
-        args = args <> kw_list_to_string(last, fun)
-        target <> "(" <> args <> ")"
-      false ->
-        args = Enum.map_join(args, ", ", &to_string(&1, fun))
-        target <> "(" <> args <> ")"
+  defp args_to_string(args, fun) do
+    { list, last } = :elixir_utils.split_last(args)
+
+    if last != [] and Keyword.keyword?(last) do
+      args = Enum.map_join(list, ", ", &to_string(&1, fun))
+      if list != [], do: args = args <> ", "
+      args <> kw_list_to_string(last, fun)
+    else
+      Enum.map_join(args, ", ", &to_string(&1, fun))
     end
   end
 
@@ -483,8 +507,8 @@ defmodule Macro do
   end
 
   @doc """
-  Receives an AST node and expands it once. 
-  
+  Receives an AST node and expands it once.
+
   The following contents are expanded:
 
   * Macros (local or remote);
@@ -665,8 +689,8 @@ defmodule Macro do
 
   @doc """
   Receives an AST node and expands it until it no longer represents
-  a macro. 
-  
+  a macro.
+
   Check `expand_once/2` for more information on how
   expansion works.
   """
@@ -715,7 +739,7 @@ defmodule Macro do
   @doc """
   Recursively traverses the quoted expression checking if all sub-terms are
   safe.
- 
+
   Terms are considered safe if they represent data structures and don't actually
   evaluate code. Returns `:ok` unless a given term is unsafe,
   which is returned as `{ :unsafe, term }`.

lib/elixir/test/elixir/macro_test.exs

@@ -39,7 +39,7 @@ defmodule MacroTest do
   test :escape_works_recursively do
     assert [1,{:{}, [], [:a,:b,:c]}, 3] == Macro.escape([1, { :a, :b, :c }, 3])
   end
-  
+
   test :escape_improper do
     assert [{:|, [], [1,2]}] == Macro.escape([1|2])
     assert [1,{:|, [], [2,3]}] == Macro.escape([1,2|3])
@@ -330,6 +330,8 @@ defmodule MacroTest do
   end
 
   test :containers_to_string do
+    assert Macro.to_string(quote do: {})   == "{}"
+    assert Macro.to_string(quote do: [])   == "[]"
     assert Macro.to_string(quote do: { 1, 2, 3 })   == "{1, 2, 3}"
     assert Macro.to_string(quote do: [ 1, 2, 3 ])   == "[1, 2, 3]"
     assert Macro.to_string(quote do: << 1, 2, 3 >>) == "<<1, 2, 3>>"
@@ -366,10 +368,20 @@ defmodule MacroTest do
   end
 
   test :last_arg_kw_list do
+    assert Macro.to_string(quote do: foo([])) == "foo([])"
     assert Macro.to_string(quote do: foo(x: y)) == "foo(x: y)"
     assert Macro.to_string(quote do: foo(x: 1 + 2)) == "foo(x: 1 + 2)"
     assert Macro.to_string(quote do: foo(x: y, p: q)) == "foo(x: y, p: q)"
     assert Macro.to_string(quote do: foo(a, x: y, p: q)) == "foo(a, x: y, p: q)"
+
+
+    assert Macro.to_string(quote do: { [] }) == "{[]}"
+    assert Macro.to_string(quote do: { [a: b] }) == "{[a: b]}"
+    assert Macro.to_string(quote do: { x, a: b }) == "{x, a: b}"
+    assert Macro.to_string(quote do: []) == "[]"
+    assert Macro.to_string(quote do: [a: b]) == "[a: b]"
+    assert Macro.to_string(quote do: [[a: b]]) == "[[a: b]]"
+    assert Macro.to_string(quote do: [x, a: b]) == "[x, a: b]"
   end
 
   test :to_string_with_fun do