Format source code with new rules

Author: eksperimental

lib/elixir/lib/code/formatter.ex

@@ -13,7 +13,7 @@ defmodule Code.Formatter do
   @ampersand_prec Code.Identifier.unary_op(:&) |> elem(1)
 
   # Operators that are composed of multiple binary operators
-  @multi_binary_operators [:..//]
+  @multi_binary_operators [:"..//"]
 
   # Operators that do not have space between operands
   @no_space_binary_operators [:.., :"//"]
@@ -516,7 +516,7 @@ defmodule Code.Formatter do
   end
 
   # 1..2//3
-  defp quoted_to_algebra({:..//, meta, [left, middle, right]}, context, state) do
+  defp quoted_to_algebra({:"..//", meta, [left, middle, right]}, context, state) do
     quoted_to_algebra({:"//", meta, [{:.., meta, [left, middle]}, right]}, context, state)
   end
 

lib/elixir/lib/code/identifier.ex

@@ -83,7 +83,7 @@ defmodule Code.Identifier do
     charlist = Atom.to_charlist(atom)
 
     cond do
-      atom in [:%, :%{}, :{}, :<<>>, :..., :.., :., :..//, :->] ->
+      atom in [:%, :%{}, :{}, :<<>>, :..., :.., :., :"..//", :->] ->
         :not_callable
 
       atom in [:"::", :"//"] ->

lib/elixir/lib/exception.ex

@@ -253,7 +253,7 @@ defmodule Exception do
   defp rewrite_arg(arg) do
     Macro.prewalk(arg, fn
       {:%{}, meta, [__struct__: Range, first: first, last: last, step: step]} ->
-        {:..//, meta, [first, last, step]}
+        {:"..//", meta, [first, last, step]}
 
       other ->
         other

lib/elixir/lib/macro.ex

@@ -1143,7 +1143,7 @@ defmodule Macro do
     :error
   end
 
-  defp op_call({:..//, _, [left, middle, right]} = ast, fun) do
+  defp op_call({:"..//", _, [left, middle, right]} = ast, fun) do
     left = op_to_string(left, fun, :.., :left)
     middle = op_to_string(middle, fun, :.., :right)
     right = op_to_string(right, fun, :"//", :right)

lib/elixir/test/elixir/kernel/parser_test.exs

@@ -17,13 +17,13 @@ defmodule Kernel.ParserTest do
 
   describe "ternary ops" do
     test "root" do
-      assert parse!("1..2//3") == {:..//, [line: 1], [1, 2, 3]}
-      assert parse!("(1..2)//3") == {:..//, [line: 1], [1, 2, 3]}
+      assert parse!("1..2//3") == {:"..//", [line: 1], [1, 2, 3]}
+      assert parse!("(1..2)//3") == {:"..//", [line: 1], [1, 2, 3]}
     end
 
     test "with do-blocks" do
       assert parse!("foo do end..bar do end//baz do end") == {
-               :..//,
+               :"..//",
                [line: 1],
                [
                  {:foo, [line: 1], [[do: {:__block__, [], []}]]},
@@ -35,7 +35,7 @@ defmodule Kernel.ParserTest do
 
     test "with no parens" do
       assert parse!("1..foo do end//bar bat, baz") == {
-               :..//,
+               :"..//",
                [line: 1],
                [
                  1,