Improve some docs

Author: José Valim

lib/elixir/lib/code.ex

@@ -140,8 +140,8 @@ defmodule Code do
   end
 
   @doc """
-  Converts the given string to AST. It returns { :ok, ast }
-  if it succeeds, { :error, { line, error, token } } otherwise.
+  Converts the given string to AST. It returns `{ :ok, ast }`
+  if it succeeds, `{ :error, { line, error, token } }` otherwise.
 
   ## Options
 
@@ -270,6 +270,15 @@ defmodule Code do
     :elixir_compiler.string :unicode.characters_to_list(string), file
   end
 
+  @doc """
+  Compiles the quoted expression and returns a list of tuples where
+  the first element is the module name and the second one is its
+  binary.
+  """
+  def compile_quoted(quoted, file // "nofile") when is_binary(file) do
+    :elixir_compiler.quoted [quoted], file
+  end
+
   @doc """
   Ensures the given module is loaded. If the module is already
   loaded, it works as no-op. If the module was not loaded yet,

lib/elixir/lib/macro.ex

@@ -164,8 +164,8 @@ defmodule Macro do
 
   @doc %B"""
   Unescape the given chars according to the map given.
-  Check `unescape/1` if you want to use the same map as
-  Elixir single- and double-quoted strings.
+  Check `unescape_binary/1` if you want to use the same map
+  as Elixir single- and double-quoted strings.
 
   ## Map
 
@@ -211,19 +211,21 @@ defmodule Macro do
 
   @doc """
   Unescape the given tokens according to the default map.
-  Check `unescape/1` and `unescape/2` for more information
-  about unescaping. 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__` for examples.
+  Check `unescape_binary/1` and `unescape_binary/2` for more
+  information about unescaping.
+
+  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__`
+  for examples.
   """
   def unescape_tokens(tokens) do
     :elixir_interpolation.unescape_tokens(tokens)
   end
 
   @doc """
   Unescape the given tokens according to the given map.
-  Check `unescape_tokens/1` and `unescaped/2` for more information.
+  Check `unescape_tokens/1` and `unescape_binary/2` for more information.
   """
   def unescape_tokens(tokens, map) do
     :elixir_interpolation.unescape_tokens(tokens, map)
@@ -597,16 +599,16 @@ defmodule Macro do
     do_safe_term(terms) || :ok
   end
 
-  def do_safe_term({ local, _, terms }) when local in [:{}, :[], :__aliases__] do
+  defp do_safe_term({ local, _, terms }) when local in [:{}, :[], :__aliases__] do
     do_safe_term(terms)
   end
 
-  def do_safe_term({ unary, _, [term] }) when unary in [:+, :-] do
+  defp do_safe_term({ unary, _, [term] }) when unary in [:+, :-] do
     do_safe_term(term)
   end
 
-  def do_safe_term({ left, right }), do: do_safe_term(left) || do_safe_term(right)
-  def do_safe_term(terms) when is_list(terms),  do: Enum.find_value(terms, do_safe_term(&1))
-  def do_safe_term(terms) when is_tuple(terms), do: { :unsafe, terms }
-  def do_safe_term(_), do: nil
+  defp do_safe_term({ left, right }), do: do_safe_term(left) || do_safe_term(right)
+  defp do_safe_term(terms) when is_list(terms),  do: Enum.find_value(terms, do_safe_term(&1))
+  defp do_safe_term(terms) when is_tuple(terms), do: { :unsafe, terms }
+  defp do_safe_term(_), do: nil
 end

lib/elixir/src/elixir_compiler.erl

@@ -22,11 +22,14 @@ get_opts() ->
 %% Compiles the given string.
 
 string(Contents, File) when is_list(Contents), is_binary(File) ->
+  Forms = elixir_translator:'forms!'(Contents, 1, File, []),
+  quoted(Forms, File).
+
+quoted(Forms, File) when is_binary(File) ->
   Previous = get(elixir_compiled),
 
   try
     put(elixir_compiled, []),
-    Forms = elixir_translator:'forms!'(Contents, 1, File, []),
     eval_forms(Forms, 1, [], elixir:scope_for_eval([{file,File}])),
     lists:reverse(get(elixir_compiled))
   after