Remove deprecated code

Author: José Valim

lib/elixir/lib/inspect/algebra.ex

@@ -432,13 +432,7 @@ defmodule Inspect.Algebra do
   """
   @spec surround_many(binary, [any], binary, integer | :infinity, (term -> t), binary) :: t
   def surround_many(left, docs, right, opts, fun, separator \\ @surround_separator) do
-    if is_integer(opts) do
-      IO.write :stderr, "Inspect.Algebra.surround_many/6 with an integer limit is deprecated, " <>
-                        "please pass Inspect.Opts instead\n#{Exception.format_stacktrace}" 
-      old_surround_many(left, docs, right, opts, fun, separator)
-    else
-      do_surround_many(left, docs, right, opts.limit, opts, fun, separator)
-    end
+    do_surround_many(left, docs, right, opts.limit, opts, fun, separator)
   end
 
   def do_surround_many(left, [], right, _, _opts, _fun, _) do
@@ -473,36 +467,6 @@ defmodule Inspect.Algebra do
     )
   end
 
-  def old_surround_many(left, [], right, _, _fun, _) do
-    concat(left, right)
-  end
-
-  def old_surround_many(left, docs, right, limit, fun, sep) do
-    surround(left, old_surround_many(docs, limit, fun, sep), right)
-  end
-
-  defp old_surround_many(_, 0, _fun, _sep) do
-    "..."
-  end
-
-  defp old_surround_many([h], _limit, fun, _sep) do
-    fun.(h)
-  end
-
-  defp old_surround_many([h|t], limit, fun, sep) when is_list(t) do
-    glue(
-      concat(fun.(h), sep),
-      old_surround_many(t, decrement(limit), fun, sep)
-    )
-  end
-
-  defp old_surround_many([h|t], _limit, fun, _sep) do
-    glue(
-      concat(fun.(h), @tail_separator),
-      fun.(t)
-    )
-  end
-
   defp decrement(:infinity), do: :infinity
   defp decrement(counter),   do: counter - 1
 
@@ -518,11 +482,6 @@ defmodule Inspect.Algebra do
     format(w, 0, [{0, default_mode(w), doc_group(d)}])
   end
 
-  @doc false
-  def pretty(d, w) do
-    format(d, w) |> IO.iodata_to_binary
-  end
-
   defp default_mode(:infinity), do: :flat
   defp default_mode(_),         do: :break
 

lib/elixir/lib/io/ansi.ex

@@ -7,10 +7,6 @@ defmodule IO.ANSI.Sequence do
         "\e[#{unquote(code)}#{unquote(terminator)}"
       end
 
-      defp escape_sequence(unquote(Atom.to_char_list(name))) do
-        unquote(name)()
-      end
-
       defp format_sequence(unquote(name)) do
         unquote(name)()
       end
@@ -32,12 +28,6 @@ defmodule IO.ANSI do
   @typep ansilist :: maybe_improper_list(char() | ansicode() | binary() | ansilist(), binary() | ansicode() | [])
   @type  ansidata :: ansilist() | ansicode() | binary()
 
-  @doc false
-  def terminal?(device \\ :erlang.group_leader) do
-    !match?({:win32, _}, :os.type()) and
-      match?({:ok, _}, :io.columns(device))
-  end
-
   @doc """
   Checks if ANSI coloring is supported and enabled on this machine.
 
@@ -144,10 +134,6 @@ defmodule IO.ANSI do
   @doc "Clear screen"
   defsequence :clear, "2", "J"
 
-  defp escape_sequence(other) do
-    raise ArgumentError, "invalid ANSI sequence specification: #{other}"
-  end
-
   defp format_sequence(other) do
     raise ArgumentError, "invalid ANSI sequence specification: #{other}"
   end
@@ -222,56 +208,4 @@ defmodule IO.ANSI do
   defp do_format([], [], acc, _emit, _append_reset) do
     acc
   end
-
-  @doc false
-  def escape(string, emit \\ terminal?) when is_binary(string) and is_boolean(emit) do
-    {rendered, emitted} = do_escape(string, emit, false, nil, [])
-    if emitted do
-      rendered <> reset
-    else
-      rendered
-    end
-  end
-
-  @doc false
-  def escape_fragment(string, emit \\ terminal?) when is_binary(string) and is_boolean(emit) do
-    {escaped, _emitted} = do_escape(string, emit, false, nil, [])
-    escaped
-  end
-
-  defp do_escape(<<?}, t :: binary>>, emit, emitted, buffer, acc) when is_list(buffer) do
-    sequences =
-      buffer
-      |> Enum.reverse()
-      |> :string.tokens(',')
-      |> Enum.map(&(&1 |> :string.strip |> escape_sequence))
-      |> Enum.reverse()
-
-    if emit and sequences != [] do
-      do_escape(t, emit, true, nil, sequences ++ acc)
-    else
-      do_escape(t, emit, emitted, nil, acc)
-    end
-  end
-
-  defp do_escape(<<h, t :: binary>>, emit, emitted, buffer, acc) when is_list(buffer) do
-    do_escape(t, emit, emitted, [h|buffer], acc)
-  end
-
-  defp do_escape(<<>>, _emit, _emitted, buffer, _acc) when is_list(buffer) do
-    buffer = IO.iodata_to_binary Enum.reverse(buffer)
-    raise ArgumentError, "missing } for escape fragment #{buffer}"
-  end
-
-  defp do_escape(<<?%, ?{, t :: binary>>, emit, emitted, nil, acc) do
-    do_escape(t, emit, emitted, [], acc)
-  end
-
-  defp do_escape(<<h, t :: binary>>, emit, emitted, nil, acc) do
-    do_escape(t, emit, emitted, nil, [h|acc])
-  end
-
-  defp do_escape(<<>>, _emit, emitted, nil, acc) do
-    {IO.iodata_to_binary(Enum.reverse(acc)), emitted}
-  end
 end

lib/elixir/lib/io/ansi/docs.ex

@@ -479,11 +479,6 @@ defmodule IO.ANSI.Docs do
 
   defp color(style, colors) do
     color = colors[style]
-    if is_binary(color) do
-      IO.puts :stderr, "warning: ANSI colors as strings is deprecated, " <>
-                       "they now must be a list of atoms, got #{inspect color} for #{inspect style}"
-      color = String.split(color, ",") |> Enum.map(&String.to_atom/1)
-    end
     IO.ANSI.format_fragment(color, colors[:enabled])
   end
 

lib/elixir/lib/system.ex

@@ -218,15 +218,6 @@ defmodule System do
     :elixir_code_server.cast {:at_exit, fun}
   end
 
-  @doc false
-  def cmd(command) when is_list(command) do
-    :os.cmd(command)
-  end
-
-  def cmd(command) when is_binary(command) do
-    List.to_string :os.cmd(String.to_char_list(command))
-  end
-
   @doc """
   Locates an executable on the system.
 

lib/elixir/src/elixir.erl

@@ -54,12 +54,17 @@ config_change(_Changed, _New, _Remove) ->
 
 start_cli() ->
   {ok, _} = application:ensure_all_started(?MODULE),
+
   %% We start the Logger so tools that depend on Elixir
   %% always have the Logger directly accessible. However
   %% Logger is not a dependency of the Elixir application,
   %% which means releases that want to use Logger must
   %% always list it as part of its applications.
-  _ = application:start(logger),
+  _ = case code:ensure_loaded('Elixir.Logger') of
+    {module, _} -> application:start(logger);
+    {error, _}  -> ok
+  end,
+
   'Elixir.Kernel.CLI':main(init:get_plain_arguments()).
 
 %% EVAL HOOKS

lib/elixir/src/elixir_bitstring.erl

@@ -36,7 +36,7 @@ expand_bitstr(Fun, [H|T], Acc, E) ->
 %% Expand bit info
 
 expand_bit_info(Meta, Info, E) ->
-  expand_bit_info(Meta, unpack_bit_info(Meta, Info, E), default, [], E).
+  expand_bit_info(Meta, unpack_bit_info(Info, []), default, [], E).
 
 expand_bit_info(Meta, [{size, _, [_]=Args}|T], Size, Types, E) ->
   case Size of
@@ -111,18 +111,9 @@ handle_unknown_bit_info(Meta, Expr, T, Size, Types, E) ->
       elixir_errors:compile_error(Meta, ?m(E, file),
         "unknown bitstring specifier ~ts", ['Elixir.Macro':to_string(Expr)]);
     Info ->
-      expand_bit_info(Meta, unpack_bit_info(Meta, Info, E) ++ T, Size, Types, E)
+      expand_bit_info(Meta, unpack_bit_info(Info, []) ++ T, Size, Types, E)
   end.
 
-%% We can remove unpack_bit_info/3 once deprecated.
-unpack_bit_info(Meta, [H|T], E) ->
-  elixir_errors:warn(?line(Meta), ?m(E, file), "passing a list of bitstring modifiers is deprecated, "
-    "please separate them with - instead"),
-  Dashed = lists:foldl(fun(I, Acc) -> {'-', Meta, [Acc, I]} end, H, T),
-  unpack_bit_info(Dashed, []);
-unpack_bit_info(_Meta, Expr, _E) ->
-  unpack_bit_info(Expr, []).
-
 unpack_bit_info({'-', _, [H, T]}, Acc) ->
   unpack_bit_info(H, unpack_bit_info(T, Acc));
 unpack_bit_info({'*', _, [{'_', _, Atom}, Unit]}, Acc) when is_atom(Atom) and is_integer(Unit) ->

lib/elixir/src/elixir_dispatch.erl

@@ -519,15 +519,5 @@ deprecation_message(Warning, Message) ->
     Message -> Warning ++ ", " ++ Message
   end.
 
-deprecation('Elixir.System', 'cmd', 1) ->
-  "use System.cmd/3 instead";
-deprecation('Elixir.Inspect.Algebra', 'pretty', 2) ->
-  "use Inspect.Algebra.format/2 instead";
-deprecation('Elixir.IO.ANSI', 'escape', _) ->
-  "use the new API in IO.ANSI.format/2 instead";
-deprecation('Elixir.IO.ANSI', 'escape_fragment', _) ->
-  "use the new API in IO.ANSI.format_fragment/2 instead";
-deprecation('Elixir.IO.ANSI', 'terminal?', _) ->
-  "use IO.ANSI.enabled?/0 instead";
 deprecation(_, _, _) ->
   false.

lib/elixir/src/elixir_interpolation.erl

@@ -74,104 +74,51 @@ unescape_chars(String) ->
   unescape_chars(String, fun unescape_map/1).
 
 unescape_chars(String, Map) ->
-  Octals = Map($0) /= false,
-  Hex    = Map($x) == true,
-  unescape_chars(String, Map, Octals, Hex, <<>>).
+  unescape_chars(String, Map, Map($x) == true, <<>>).
 
-%% Deprecated
+unescape_chars(<<$\\,$x,A,B,Rest/binary>>, Map, true, Acc) when ?is_hex(A), ?is_hex(B) ->
+  append_escaped(Rest, Map, [A,B], true, Acc, 16);
 
-unescape_chars(<<$\\,A,B,C,Rest/binary>>, Map, true, Hex, Acc) when ?is_octal(A), A =< $3, ?is_octal(B), ?is_octal(C) ->
-  io:format(standard_error, "warning: octals inside strings/sigils/chars are deprecated, got: \\~ts~n", [<<A, B, C>>]),
-  append_escaped(Rest, Map, [A,B,C], true, Hex, Acc, 8);
+unescape_chars(<<$\\,$x,A,Rest/binary>>, Map, true, Acc) when ?is_hex(A) ->
+  append_escaped(Rest, Map, [A], true, Acc, 16);
 
-unescape_chars(<<$\\,A,B,Rest/binary>>, Map, true, Hex, Acc) when ?is_octal(A), ?is_octal(B) ->
-  io:format(standard_error, "warning: octals inside strings/sigils/chars are deprecated, got: \\~ts~n", [<<A, B>>]),
-  append_escaped(Rest, Map, [A,B], true, Hex, Acc, 8);
+unescape_chars(<<$\\,$x,${,A,$},Rest/binary>>, Map, true, Acc) when ?is_hex(A) ->
+  append_escaped(Rest, Map, [A], true, Acc, 16);
 
-unescape_chars(<<$\\,$0,Rest/binary>>, Map, true, Hex, Acc) ->
-  append_escaped(Rest, Map, [$0], true, Hex, Acc, 8);
+unescape_chars(<<$\\,$x,${,A,B,$},Rest/binary>>, Map, true, Acc) when ?is_hex(A), ?is_hex(B) ->
+  append_escaped(Rest, Map, [A,B], true, Acc, 16);
 
-unescape_chars(<<$\\,A,Rest/binary>>, Map, true, Hex, Acc) when ?is_octal(A) ->
-  io:format(standard_error, "warning: octals inside strings/sigils/chars are deprecated, got: \\~ts~n", [<<A>>]),
-  append_escaped(Rest, Map, [A], true, Hex, Acc, 8);
+unescape_chars(<<$\\,$x,${,A,B,C,$},Rest/binary>>, Map, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C) ->
+  append_escaped(Rest, Map, [A,B,C], true, Acc, 16);
 
-unescape_chars(<<$\\,$X,A,B,Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B) ->
-  io:format(standard_error, "warning: \\X inside strings/sigils/chars is deprecated, please use \\x instead~n", []),
-  append_escaped(Rest, Map, [A,B], Octal, true, Acc, 16);
+unescape_chars(<<$\\,$x,${,A,B,C,D,$},Rest/binary>>, Map, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
+  append_escaped(Rest, Map, [A,B,C,D], true, Acc, 16);
 
-unescape_chars(<<$\\,$X,A,Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A) ->
-  io:format(standard_error, "warning: \\X inside strings/sigils/chars is deprecated, please use \\x instead~n", []),
-  append_escaped(Rest, Map, [A], Octal, true, Acc, 16);
+unescape_chars(<<$\\,$x,${,A,B,C,D,E,$},Rest/binary>>, Map, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) ->
+  append_escaped(Rest, Map, [A,B,C,D,E], true, Acc, 16);
 
-unescape_chars(<<$\\,$X,${,A,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A) ->
-  io:format(standard_error, "warning: \\X inside strings/sigils/chars is deprecated, please use \\x instead~n", []),
-  append_escaped(Rest, Map, [A], Octal, true, Acc, 16);
+unescape_chars(<<$\\,$x,${,A,B,C,D,E,F,$},Rest/binary>>, Map, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) ->
+  append_escaped(Rest, Map, [A,B,C,D,E,F], true, Acc, 16);
 
-unescape_chars(<<$\\,$X,${,A,B,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B) ->
-  io:format(standard_error, "warning: \\X inside strings/sigils/chars is deprecated, please use \\x instead~n", []),
-  append_escaped(Rest, Map, [A,B], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$X,${,A,B,C,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C) ->
-  io:format(standard_error, "warning: \\X inside strings/sigils/chars is deprecated, please use \\x instead~n", []),
-  append_escaped(Rest, Map, [A,B,C], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$X,${,A,B,C,D,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
-  io:format(standard_error, "warning: \\X inside strings/sigils/chars is deprecated, please use \\x instead~n", []),
-  append_escaped(Rest, Map, [A,B,C,D], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$X,${,A,B,C,D,E,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) ->
-  io:format(standard_error, "warning: \\X inside strings/sigils/chars is deprecated, please use \\x instead~n", []),
-  append_escaped(Rest, Map, [A,B,C,D,E], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$X,${,A,B,C,D,E,F,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) ->
-  io:format(standard_error, "warning: \\X inside strings/sigils/chars is deprecated, please use \\x instead~n", []),
-  append_escaped(Rest, Map, [A,B,C,D,E,F], Octal, true, Acc, 16);
-
-%% End of deprecated
-
-unescape_chars(<<$\\,$x,A,B,Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B) ->
-  append_escaped(Rest, Map, [A,B], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$x,A,Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A) ->
-  append_escaped(Rest, Map, [A], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$x,${,A,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A) ->
-  append_escaped(Rest, Map, [A], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$x,${,A,B,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B) ->
-  append_escaped(Rest, Map, [A,B], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$x,${,A,B,C,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C) ->
-  append_escaped(Rest, Map, [A,B,C], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$x,${,A,B,C,D,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
-  append_escaped(Rest, Map, [A,B,C,D], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$x,${,A,B,C,D,E,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) ->
-  append_escaped(Rest, Map, [A,B,C,D,E], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$x,${,A,B,C,D,E,F,$},Rest/binary>>, Map, Octal, true, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) ->
-  append_escaped(Rest, Map, [A,B,C,D,E,F], Octal, true, Acc, 16);
-
-unescape_chars(<<$\\,$x,_/binary>>, _Map, _Octal, true, _Acc) ->
+unescape_chars(<<$\\,$x,_/binary>>, _Map, true, _Acc) ->
   Msg = <<"missing hex sequence after \\x">>,
   error('Elixir.ArgumentError':exception([{message,Msg}]));
 
-unescape_chars(<<$\\,Escaped,Rest/binary>>, Map, Octals, Hex, Acc) ->
+unescape_chars(<<$\\,Escaped,Rest/binary>>, Map, Hex, Acc) ->
   case Map(Escaped) of
-    false -> unescape_chars(Rest, Map, Octals, Hex, <<Acc/binary, $\\, Escaped>>);
-    Other -> unescape_chars(Rest, Map, Octals, Hex, <<Acc/binary, Other>>)
+    false -> unescape_chars(Rest, Map, Hex, <<Acc/binary, $\\, Escaped>>);
+    Other -> unescape_chars(Rest, Map, Hex, <<Acc/binary, Other>>)
   end;
 
-unescape_chars(<<Char, Rest/binary>>, Map, Octals, Hex, Acc) ->
-  unescape_chars(Rest, Map, Octals, Hex, <<Acc/binary, Char>>);
+unescape_chars(<<Char, Rest/binary>>, Map, Hex, Acc) ->
+  unescape_chars(Rest, Map, Hex, <<Acc/binary, Char>>);
 
-unescape_chars(<<>>, _Map, _Octals, _Hex, Acc) -> Acc.
+unescape_chars(<<>>, _Map, _Hex, Acc) -> Acc.
 
-append_escaped(Rest, Map, List, Octal, Hex, Acc, Base) ->
+append_escaped(Rest, Map, List, Hex, Acc, Base) ->
   Codepoint = list_to_integer(List, Base),
   try <<Acc/binary, Codepoint/utf8>> of
-    Binary -> unescape_chars(Rest, Map, Octal, Hex, Binary)
+    Binary -> unescape_chars(Rest, Map, Hex, Binary)
   catch
     error:badarg ->
       Msg = <<"invalid or reserved unicode codepoint ", (integer_to_binary(Codepoint))/binary>>,