Remove deprecated branches

Author: José Valim

lib/elixir/lib/collectable.ex

@@ -21,21 +21,13 @@ defprotocol Collectable do
   shape where just the range limits are stored.
 
   The `Collectable` module was designed to fill the gap left by the
-  `Enumerable` protocol. It provides two functions: `into/1` and `empty/1`.
-
-  `into/1` can be seen as the opposite of `Enumerable.reduce/3`. If
-  `Enumerable` is about taking values out, `Collectable.into/1` is about
-  collecting those values into a structure.
+  `Enumerable` protocol. `into/1` can be seen as the opposite of
+  `Enumerable.reduce/3`. If `Enumerable` is about taking values out,
+  `Collectable.into/1` is about collecting those values into a structure.
   """
 
   @type command :: {:cont, term} | :done | :halt
 
-  @doc """
-  Receives a collectable structure and returns an empty one.
-  """
-  @spec empty(t) :: t
-  def empty(collectable)
-
   @doc """
   Returns a function that collects values alongside
   the initial accumulation value.
@@ -55,10 +47,6 @@ defprotocol Collectable do
 end
 
 defimpl Collectable, for: List do
-  def empty(_list) do
-    []
-  end
-
   def into(original) do
     {[], fn
       list, {:cont, x} -> [x|list]
@@ -69,10 +57,6 @@ defimpl Collectable, for: List do
 end
 
 defimpl Collectable, for: BitString do
-  def empty(_bitstring) do
-    ""
-  end
-
   def into(original) do
     {original, fn
       acc, {:cont, x} when is_bitstring(x) -> [acc|x]
@@ -83,10 +67,6 @@ defimpl Collectable, for: BitString do
 end
 
 defimpl Collectable, for: Map do
-  def empty(_map) do
-    %{}
-  end
-
   def into(original) do
     {original, fn
       map, {:cont, {k, v}} -> :maps.put(k, v, map)

lib/elixir/lib/enum.ex

@@ -1798,15 +1798,6 @@ defmodule Enum do
     reverse(collection) |> :lists.reverse
   end
 
-  @doc false
-  def traverse(collection, transform) when is_list(collection) do
-    :lists.map(transform, collection)
-  end
-
-  def traverse(collection, transform) do
-    into(collection, apply(Collectable, :empty, [collection]), transform)
-  end
-
   @doc """
   Enumerates the collection, removing all duplicated items.
 

lib/elixir/lib/gen_event.ex

@@ -355,8 +355,6 @@ defmodule GenEvent do
   @spec add_handler(manager, handler, term, [monitor: boolean]) :: :ok | {:error, term}
   def add_handler(manager, handler, args, options \\ []) do
     cond do
-      Keyword.get(options, :link, false) ->
-        raise ArgumentError, message: "GenEvent.add_handler/4 with link is deprecated and no longer works"
       Keyword.get(options, :monitor, false) ->
         rpc(manager, {:add_mon_handler, handler, args, self()})
       true ->
@@ -486,8 +484,6 @@ defmodule GenEvent do
   @spec swap_handler(manager, handler, term, handler, term, [monitor: boolean]) :: :ok | {:error, term}
   def swap_handler(manager, handler1, args1, handler2, args2, options \\ []) do
     cond do
-      Keyword.get(options, :link, false) ->
-        raise ArgumentError, message: "GenEvent.swap_handler/6 with link is deprecated and no longer works"
       Keyword.get(options, :monitor, false) ->
         rpc(manager, {:swap_mon_handler, handler1, args1, handler2, args2, self()})
       true ->

lib/elixir/lib/integer.ex

@@ -5,11 +5,6 @@ defmodule Integer do
 
   import Bitwise
 
-  @doc false
-  defmacro odd?(n) do
-    quote do: (unquote(n) &&& 1) == 1
-  end
-
   @doc """
   Determines if an integer is odd.
 
@@ -21,11 +16,6 @@ defmodule Integer do
     quote do: (unquote(n) &&& 1) == 1
   end
 
-  @doc false
-  defmacro even?(n) do
-    quote do: (unquote(n) &&& 1) == 0
-  end
-
   @doc """
   Determines if an integer is even.
 

lib/elixir/lib/kernel.ex

@@ -1875,11 +1875,6 @@ defmodule Kernel do
     quote do: List.Chars.to_char_list(unquote(arg))
   end
 
-  @doc false
-  defmacro nil?(x) do
-    quote do: unquote(x) == nil
-  end
-
   @doc """
   Checks if the given argument is nil or not.
   Allowed in guard clauses.

lib/elixir/lib/record.ex

@@ -56,23 +56,6 @@ defmodule Record do
     Macro.escape Record.Extractor.extract(name, opts)
   end
 
-  @doc false
-  defmacro record?(data, kind) do
-    case Macro.Env.in_guard?(__CALLER__) do
-      true ->
-        quote do
-          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
-            and :erlang.element(1, unquote(data)) == unquote(kind)
-        end
-      false ->
-        quote do
-          result = unquote(data)
-          is_tuple(result) and tuple_size(result) > 0
-            and :erlang.element(1, result) == unquote(kind)
-        end
-    end
-  end
-
   @doc """
   Checks if the given `data` is a record of `kind`.
 
@@ -101,23 +84,6 @@ defmodule Record do
     end
   end
 
-  @doc false
-  defmacro record?(data) do
-    case Macro.Env.in_guard?(__CALLER__) do
-      true ->
-        quote do
-          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
-            and is_atom(:erlang.element(1, unquote(data)))
-        end
-      false ->
-        quote do
-          result = unquote(data)
-          is_tuple(result) and tuple_size(result) > 0
-            and is_atom(:erlang.element(1, result))
-        end
-    end
-  end
-
   @doc """
   Checks if the given `data` is a record.
 

lib/elixir/lib/stream.ex

@@ -1017,17 +1017,13 @@ defmodule Stream do
     {:halted, acc}
   end
 
-  # TODO: We should check this is a two-item tuple once
-  # we remove support for the deprecated nil
-  # TODO: Support non lists once the previous format
-  # is removed
   defp do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun) do
     try do
       # Optimize the most common cases
       case next_fun.(next_acc) do
         {[], next_acc}  -> {:opt, {:cont, acc}, next_acc}
         {[v], next_acc} -> {:opt, fun.(v, acc), next_acc}
-        other           -> other
+        {_, _} = other  -> other
       end
     catch
       kind, reason ->
@@ -1042,15 +1038,10 @@ defmodule Stream do
       {list, next_acc} when is_list(list) ->
         do_list_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun,
                          &Enumerable.List.reduce(list, &1, fun))
-      nil ->
-        IO.write :stderr, "warning: returning nil from Stream.resource/3 is deprecated, " <>
-                          "please return {:halt, acc} instead\n#{Exception.format_stacktrace}"
-        do_resource(next_acc, next_fun, {:halt, acc}, fun, after_fun)
-      {v, next_acc} ->
-        IO.write :stderr, "warning: returning {next, acc} from Stream.resource/3 is deprecated, " <>
-                          "please return {[val], acc} instead\n#{Exception.format_stacktrace}"
-        do_list_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun,
-                         &Enumerable.List.reduce([v], &1, fun))
+      {enum, next_acc} ->
+        inner = &do_resource_each(&1, &2, fun)
+        do_enum_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun,
+                         &Enumerable.reduce(enum, &1, inner))
     end
   end
 
@@ -1072,6 +1063,33 @@ defmodule Stream do
     end
   end
 
+  defp do_enum_resource(next_acc, next_fun, {op, acc}, fun, after_fun, reduce) do
+    try do
+      reduce.({op, [:outer|acc]})
+    catch
+      kind, reason ->
+        stacktrace = System.stacktrace
+        after_fun.(next_acc)
+        :erlang.raise(kind, reason, stacktrace)
+    else
+      {:halted, [:outer|acc]} ->
+        do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun)
+      {:halted, [:inner|acc]} ->
+        do_resource(next_acc, next_fun, {:halt, acc}, fun, after_fun)
+      {:done, [_|acc]} ->
+        do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun)
+      {:suspended, [_|acc], c} ->
+        {:suspended, acc, &do_enum_resource(next_acc, next_fun, &1, fun, after_fun, c)}
+    end
+  end
+
+  defp do_resource_each(x, [:outer|acc], f) do
+    case f.(x, acc) do
+      {:halt, res} -> {:halt, [:inner|res]}
+      {op, res}    -> {op, [:outer|res]}
+    end
+  end
+
   @doc """
   Emits a sequence of values for the given accumulator.
 

lib/elixir/src/elixir_dispatch.erl

@@ -522,19 +522,5 @@ deprecation_message(Warning, Message) ->
     Message -> Warning ++ ", " ++ Message
   end.
 
-deprecation('Elixir.Collectable', 'empty', 1) ->
-  true;
-deprecation('Elixir.Enum', 'traverse', 2) ->
-  true;
-deprecation('Elixir.Kernel', 'nil?', 1) ->
-  true;
-deprecation('Elixir.Record', 'record?', 1) ->
-  true;
-deprecation('Elixir.Record', 'record?', 2) ->
-  true;
-deprecation('Elixir.Integer', 'even?', 1) ->
-  true;
-deprecation('Elixir.Integer', 'odd?', 1) ->
-  true;
 deprecation(_, _, _) ->
   false.

lib/elixir/test/elixir/stream_test.exs

@@ -480,6 +480,40 @@ defmodule StreamTest do
     assert Process.get(:stream_resource)
   end
 
+  test "resource/3 halts with inner enum" do
+    stream = Stream.resource(fn -> 1 end,
+                             fn acc -> {acc..acc+2, acc + 1} end,
+                             fn _ -> Process.put(:stream_resource, true) end)
+
+    Process.put(:stream_resource, false)
+    assert Enum.take(stream, 5) == [1, 2, 3, 2, 3]
+    assert Process.get(:stream_resource)
+  end
+
+  test "resource/3 closes on errors with inner enum" do
+    stream = Stream.resource(fn -> 1 end,
+                             fn acc -> {acc..acc+2, acc + 1} end,
+                             fn _ -> Process.put(:stream_resource, true) end)
+
+    Process.put(:stream_resource, false)
+    stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_resource)
+  end
+
+  test "resource/3 is zippable with inner enum" do
+    stream = Stream.resource(fn -> 1 end,
+                             fn 10 -> {:halt, 10}
+                                acc -> {acc..acc+2, acc + 1}
+                             end,
+                             fn _ -> Process.put(:stream_resource, true) end)
+
+    list = Enum.to_list(stream)
+    Process.put(:stream_resource, false)
+    assert Enum.zip(list, list) == Enum.zip(stream, stream)
+    assert Process.get(:stream_resource)
+  end
+
   test "scan/2" do
     stream = Stream.scan(1..5, &(&1 + &2))
     assert is_lazy(stream)