Rename sigils from __ to sigil_$, closes #1301

Author: José Valim

CHANGELOG.md

@@ -12,7 +12,7 @@
   * [Mix] Implement `Mix.Version` for basic versioniong semantics
   * [Mix] Support creation and installation of archives (.ez files)
   * [Mix] `github: ...` shortcut now uses the faster `git` schema instead of `https`
-  * [Record] Allow types to be given to `defrecordp`
+  * [Record] Allow types to be given to `defrecord` and `defrecordp`
 
 * bug fix
   * [Kernel] The elixir executable on Windows now supports the same options as the UNIX one
@@ -32,7 +32,8 @@
   * [Bitwise] Precedence of operators used by the Bitwise module were changed. Check `elixir_parser.yrl` for more information.
   * [File] `rm_rf` and `cp_r` now returns a tuple with three elements on failures
   * [Kernel] The quoted representation for `->` clauses changed from a tuple with two elements to a tuple with three elements to support metadata
-  * [Macro] `Macro.expand/2` now expands until final form. Although this is backwards incompatible, it is **very** likely your code should expand the node until its final form, particularly if you are expecting an atom out of it
+  * [Kernel] Sigils now dispatch to `sigil_$` instead of `__$__` where `$` is the sigil caracter
+  * [Macro] `Macro.expand/2` now expands until final form. Although this is backwards incompatible, it is very likely you do not need to change your code, since expansion until its final form is recommended, particularly if you are expecting an atom out of it
   * [Mix] No longer support beam files on `mix local`
 
 # v0.9.2 (2013-06-13)

lib/elixir/lib/kernel.ex

@@ -3323,7 +3323,7 @@ defmodule Kernel do
       "f\\\#{o}o"
 
   """
-  defmacro __B__(string, []) do
+  defmacro sigil_B(string, []) do
     string
   end
 
@@ -3339,7 +3339,7 @@ defmodule Kernel do
       "foo"
 
   """
-  defmacro __b__({ :<<>>, line, pieces }, []) do
+  defmacro sigil_b({ :<<>>, line, pieces }, []) do
     { :<<>>, line, Macro.unescape_tokens(pieces) }
   end
 
@@ -3355,7 +3355,7 @@ defmodule Kernel do
       'f\\\#{o}o'
 
   """
-  defmacro __C__({ :<<>>, _line, [string] }, []) when is_binary(string) do
+  defmacro sigil_C({ :<<>>, _line, [string] }, []) when is_binary(string) do
     binary_to_list(string)
   end
 
@@ -3374,11 +3374,11 @@ defmodule Kernel do
 
   # We can skip the runtime conversion if we are
   # creating a binary made solely of series of chars.
-  defmacro __c__({ :<<>>, _line, [string] }, []) when is_binary(string) do
+  defmacro sigil_c({ :<<>>, _line, [string] }, []) when is_binary(string) do
     :unicode.characters_to_list(Macro.unescape_binary(string))
   end
 
-  defmacro __c__({ :<<>>, line, pieces }, []) do
+  defmacro sigil_c({ :<<>>, line, pieces }, []) do
     binary = { :<<>>, line, Macro.unescape_tokens(pieces) }
     quote do: :unicode.characters_to_list(unquote(binary))
   end
@@ -3392,13 +3392,13 @@ defmodule Kernel do
       true
 
   """
-  defmacro __r__({ :<<>>, _line, [string] }, options) when is_binary(string) do
+  defmacro sigil_r({ :<<>>, _line, [string] }, options) when is_binary(string) do
     binary = Macro.unescape_binary(string, Regex.unescape_map(&1))
     regex  = Regex.compile!(binary, options)
     Macro.escape(regex)
   end
 
-  defmacro __r__({ :<<>>, line, pieces }, options) do
+  defmacro sigil_r({ :<<>>, line, pieces }, options) do
     binary = { :<<>>, line, Macro.unescape_tokens(pieces, Regex.unescape_map(&1)) }
     quote do: Regex.compile!(unquote(binary), unquote(options))
   end
@@ -3413,7 +3413,7 @@ defmodule Kernel do
       true
 
   """
-  defmacro __R__({ :<<>>, _line, [string] }, options) when is_binary(string) do
+  defmacro sigil_R({ :<<>>, _line, [string] }, options) when is_binary(string) do
     regex = Regex.compile!(string, options)
     Macro.escape(regex)
   end
@@ -3438,11 +3438,11 @@ defmodule Kernel do
 
   """
 
-  defmacro __w__({ :<<>>, _line, [string] }, modifiers) when is_binary(string) do
+  defmacro sigil_w({ :<<>>, _line, [string] }, modifiers) when is_binary(string) do
     split_words(Macro.unescape_binary(string), modifiers)
   end
 
-  defmacro __w__({ :<<>>, line, pieces }, modifiers) do
+  defmacro sigil_w({ :<<>>, line, pieces }, modifiers) do
     binary = { :<<>>, line, Macro.unescape_tokens(pieces) }
     split_words(binary, modifiers)
   end
@@ -3463,7 +3463,7 @@ defmodule Kernel do
       ["foo", "\\\#{bar}", "baz"]
 
   """
-  defmacro __W__({ :<<>>, _line, [string] }, modifiers) when is_binary(string) do
+  defmacro sigil_W({ :<<>>, _line, [string] }, modifiers) when is_binary(string) do
     split_words(string, modifiers)
   end
 

lib/elixir/lib/macro.ex

@@ -153,7 +153,7 @@ defmodule Macro do
 
   Only tokens that are binaries are unescaped, all others are
   ignored. This function is useful when implementing your own
-  sigils. Check the implementation of `Kernel.__b__`
+  sigils. Check the implementation of `Kernel.sigil_b`
   for examples.
   """
   def unescape_tokens(tokens) do

lib/elixir/src/elixir_import.erl

@@ -196,18 +196,15 @@ intersection([], _All) -> [].
 
 %% Internal funs that are never imported etc.
 
-remove_underscored(default, List) -> remove_underscored(List);
-remove_underscored(_, List)       -> List.
-
-remove_underscored([{ Name, _ } = H|T]) when Name < a  ->
-  case atom_to_list(Name) of
-    [$_, $_, _, $_, $_] -> [H|remove_underscored(T)];
-    "_" ++ _            -> remove_underscored(T);
-    _                   -> [H|remove_underscored(T)]
-  end;
-
-remove_underscored(T) ->
-  T.
+remove_underscored(default, List) ->
+  lists:filter(fun({ Name, _ }) ->
+    case atom_to_list(Name) of
+      "_" ++ _ -> false;
+      _ -> true
+    end
+  end, List);
+
+remove_underscored(_, List) -> List.
 
 remove_internals(Set) ->
   ordsets:del_element({ module_info, 1 },

lib/elixir/src/elixir_parser.yrl

@@ -514,7 +514,7 @@ build_access(Expr, Access) ->
 
 build_sigil({ sigil, Line, Sigil, Parts, Modifiers }) ->
   Meta = [{line,Line}],
-  { list_to_atom([$_,$_,Sigil,$_,$_]), Meta, [ { '<<>>', Meta, Parts }, Modifiers ] }.
+  { list_to_atom("sigil_" ++ [Sigil]), Meta, [ { '<<>>', Meta, Parts }, Modifiers ] }.
 
 build_bin_string({ bin_string, _Line, [H] }) when is_binary(H) -> H;
 build_bin_string({ bin_string, Line, Args }) -> { '<<>>', [{line,Line}], Args }.

lib/elixir/test/elixir/kernel/import_test.exs

@@ -61,7 +61,6 @@ end
 defmodule Kernel.Underscored do
   def hello(x),          do: x
   def __underscore__(x), do: x
-  def __s__(x),          do: x
 end
 
 defmodule Kernel.ExplicitUnderscored do
@@ -87,11 +86,6 @@ defmodule Kernel.ImportUnderscoreTest do
     import Kernel.Underscored
     assert hello(2) == 2
   end
-
-  test :includes_sigil_like do
-    import Kernel.Underscored
-    assert __s__(3) == 3
-  end
 end
 
 defmodule Kernel.ImportMacrosTest do

lib/elixir/test/elixir/kernel/sigils_test.exs

@@ -3,19 +3,19 @@ Code.require_file "../test_helper.exs", __DIR__
 defmodule Kernel.SigilsTest do
   use ExUnit.Case, async: true
 
-  test :__b__ do
+  test :sigil_b do
     assert %b(foo) == "foo"
     assert %b(f#{:o}o) == "foo"
     assert %b(f\no) == "f\no"
   end
 
-  test :__b__with_heredoc do
+  test :sigil_b_with_heredoc do
     assert "  foo\n\n" == %b"""
       f#{:o}o\n
     """
   end
 
-  test :__B__ do
+  test :sigil_B do
     assert %B(foo) == "foo"
     assert %B[foo] == "foo"
     assert %B{foo} == "foo"
@@ -26,19 +26,19 @@ defmodule Kernel.SigilsTest do
     assert %B(f\no) == "f\\no"
   end
 
-  test :__B__with_heredoc do
+  test :sigil_B_with_heredoc do
     assert "  f\#{o}o\\n\n" == %B"""
       f#{o}o\n
     """
   end
 
-  test :__c__ do
+  test :sigil_c do
     assert %c(foo) == 'foo'
     assert %c(f#{:o}o) == 'foo'
     assert %c(f\no) == 'f\no'
   end
 
-  test :__C__ do
+  test :sigil_C do
     assert %C(foo) == 'foo'
     assert %C[foo] == 'foo'
     assert %C{foo} == 'foo'
@@ -49,7 +49,7 @@ defmodule Kernel.SigilsTest do
     assert %C(f\no) == 'f\\no'
   end
 
-  test :__w__ do
+  test :sigil_w do
     assert %w(foo bar baz) == ["foo", "bar", "baz"]
     assert %w(foo #{:bar} baz) == ["foo", "bar", "baz"]
 
@@ -72,7 +72,7 @@ defmodule Kernel.SigilsTest do
     assert %w(Foo.#{Bar})c == ['Foo.Elixir.Bar']
   end
 
-  test :__W__ do
+  test :sigil_W do
     assert %W(foo #{bar} baz) == ["foo", "\#{bar}", "baz"]
 
     assert %W(

lib/elixir/test/elixir/regex_test.exs

@@ -71,7 +71,7 @@ defmodule Regex.BinaryTest do
     assert Regex.captures(%r/c(.)/g, 'cat') == []
   end
 
-  test :__R__ do
+  test :sigil_R do
     assert Regex.match?(%R/f#{1,3}o/, "f#o")
   end