Introduce deprecations scheduled for Elixir v1.20

Author: josevalim

CHANGELOG.md

@@ -303,6 +303,16 @@ This work was performed by Jonatan Männchen and sponsored by the Erlang Ecosyst
 
 #### Elixir
 
+  * [File] `File.stream!(path, modes, lines_or_bytes)` is deprecated in favor of the correct order in `File.stream!(path, lines_or_bytes, modes)`
+  * [Kernel] Matching on the size inside a bit pattern now requires the pin operator for consistency, such as `<<x::size(^existing_var)>>`
+  * [Kernel.ParallelCompiler] `Kernel.ParallelCompiler.async/1` is deprecated in favor of `Kernel.ParallelCompiler.pmap/2`, which is more performant and deals better with edge cases
+
+#### Logger
+
+  * [Logger] `Logger.*_backend` functions are deprecated in favor of handlers. If you really want to keep on using backends, see the `:logger_backends` package
+  * [Logger] `Logger.enable/1` and `Logger.disable/1` have been deprecated in favor of `Logger.put_process_level/1` and `Logger.delete_process_level/1`
+
+
   * [Code] The `on_undefined_variable: :warn` is deprecated. Relying on undefined variables becoming function calls will not be supported in the future
   * [File] Passing a callback as third argument to `File.cp/3` is deprecated, pass it as a `on_conflict: callback` option instead
   * [File] Passing a callback as third argument to `File.cp_r/3` is deprecated, pass it as a `on_conflict: callback` option instead

lib/elixir/lib/file.ex

@@ -2159,7 +2159,12 @@ defmodule File do
   def stream!(path, line_or_bytes, modes)
 
   def stream!(path, modes, line_or_bytes) when is_list(modes) do
-    # TODO: Deprecate this on Elixir v1.20
+    # TODO: Remove me on Elixir 2.0
+    IO.warn(
+      "File.stream!(path, modes, line_or_byte) is deprecated, " <>
+        "invoke File.stream!(path, line_or_bytes, modes) instead"
+    )
+
     stream!(path, line_or_bytes, modes)
   end
 

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -19,8 +19,8 @@ defmodule Kernel.ParallelCompiler do
   @doc """
   Starts a task for parallel compilation.
   """
-  # TODO: Deprecate this on Elixir v1.20.
-  @doc deprecated: "Use `pmap/2` instead"
+  # TODO: Remove me on Elixir 2.0
+  @deprecated "Use `pmap/2` instead"
   def async(fun) when is_function(fun, 0) do
     {ref, task} = inner_async(fun)
     send(task.pid, ref)

lib/elixir/pages/references/compatibility-and-deprecations.md

@@ -90,6 +90,11 @@ The first column is the version the feature was hard deprecated. The second colu
 
 Version | Deprecated feature                                  | Replaced by (available since)
 :-------| :-------------------------------------------------- | :---------------------------------------------------------------
+[v1.20] | `<<x::size(y)>>` in patterns without `^`            | `<<x::size(^y)>>`
+[v1.20] | `File.stream!(path, modes, lines_or_bytes)`         | `File.stream!(path, lines_or_bytes, modes)`
+[v1.20] | `Kernel.ParallelCompiler.async/1`                   | `Kernel.ParallelCompiler.pmap/2`
+[v1.20] | `Logger.*_backend` functions                        | The `LoggerBackends` module from `:logger_backends` package
+[v1.20] | `Logger.enable/1` / `Logger.disable/1`              | `Logger.put_process_level/1` and `Logger.delete_process_level/1`
 [v1.19] | CLI configuration in `def project` inside `mix.exs` | Moving it to `def cli` (v1.14)
 [v1.19] | Using `,` to separate tasks in `mix do`             | Using `+` (v1.14)
 [v1.19] | Logger's `:backends` configuration                  | Logger's `:default_handler` configuration (v1.15)

lib/elixir/src/elixir_expand.erl

@@ -424,8 +424,7 @@ expand({Name, Meta, Kind}, S, E) when is_atom(Name), is_atom(Kind) ->
 
               is_map_key(Pair, Pre) ->
                 %% TODO: Remove me on Elixir 2.0
-                %% TODO: Deprecate me on Elixir 1.20
-                %% elixir_errors:file_warn(Meta, E, ?MODULE, {unpinned_bitsize_var, Name, Kind}),
+                elixir_errors:file_warn(Meta, E, ?MODULE, {unpinned_bitsize_var, Name, Kind}),
                 {ok, CurrentVersion};
 
               not is_map_key(Pair, Original) ->

lib/elixir/test/elixir/file/stream_test.exs

@@ -17,8 +17,8 @@ defmodule File.StreamTest do
     :erpc.call(node, File, :stream!, [src, lines_or_bytes_or_modes])
   end
 
-  defp stream!(node, src, lines_or_bytes, modes) do
-    :erpc.call(node, File, :stream!, [src, lines_or_bytes, modes])
+  defp stream!(node, src, modes, lines_or_bytes) do
+    :erpc.call(node, File, :stream!, [src, modes, lines_or_bytes])
   end
 
   distributed_node = :"secondary@#{node() |> Atom.to_string() |> :binary.split("@") |> tl()}"
@@ -46,7 +46,7 @@ defmodule File.StreamTest do
         assert stream.modes == [:raw, {:read_ahead, 5000}, :binary]
         assert stream.raw
 
-        stream = stream!(@node, src, [:utf8], 10)
+        stream = stream!(@node, src, 10, [:utf8])
         assert %File.Stream{} = stream
         assert stream.modes == [{:encoding, :utf8}, :binary]
         refute stream.raw
@@ -148,29 +148,29 @@ defmodule File.StreamTest do
         src = fixture_path("file.txt")
 
         assert @node
-               |> stream!(src, [{:read_offset, 0}])
+               |> stream!(src, read_offset: 0)
                |> Enum.take(1) == ["FOO\n"]
 
         assert @node
-               |> stream!(src, [{:read_offset, 1}])
+               |> stream!(src, read_offset: 1)
                |> Enum.take(1) == ["OO\n"]
 
         assert @node
-               |> stream!(src, [{:read_offset, 4}])
+               |> stream!(src, read_offset: 4)
                |> Enum.take(1) == []
 
-        assert @node |> stream!(src, 1, [{:read_offset, 1}]) |> Enum.count() == 3
-        assert @node |> stream!(src, 1, [{:read_offset, 4}]) |> Enum.count() == 0
+        assert @node |> stream!(src, 1, read_offset: 1) |> Enum.count() == 3
+        assert @node |> stream!(src, 1, read_offset: 4) |> Enum.count() == 0
       end
 
       test "applies offset after trimming BOM" do
         src = fixture_path("utf8_bom.txt")
 
         assert @node
-               |> stream!(src, [:trim_bom, {:read_offset, 4}])
+               |> stream!(src, [:trim_bom, read_offset: 4])
                |> Enum.take(1) == ["сский\n"]
 
-        assert @node |> stream!(src, 1, [:trim_bom, {:read_offset, 4}]) |> Enum.count() == 15
+        assert @node |> stream!(src, 1, [:trim_bom, read_offset: 4]) |> Enum.count() == 15
       end
 
       test "keeps BOM when raw" do
@@ -196,7 +196,7 @@ defmodule File.StreamTest do
                |> Enum.take(1) == ["Русский\n"]
 
         assert @node
-               |> stream!(src, [:trim_bom], 1)
+               |> stream!(src, 1, [:trim_bom])
                |> Enum.take(5) == [<<208>>, <<160>>, <<209>>, <<131>>, <<209>>]
 
         assert @node |> stream!(src, [:trim_bom]) |> Enum.count() == 2
@@ -208,11 +208,11 @@ defmodule File.StreamTest do
         src = fixture_path("utf8_bom.txt")
 
         assert @node
-               |> stream!(src, [{:encoding, :utf8}])
+               |> stream!(src, encoding: :utf8)
                |> Enum.take(1) == [<<239, 187, 191>> <> "Русский\n"]
 
         assert @node
-               |> stream!(src, 1, [{:encoding, :utf8}])
+               |> stream!(src, 1, encoding: :utf8)
                |> Enum.take(9) == ["\uFEFF", "Р", "у", "с", "с", "к", "и", "й", "\n"]
       end
 

lib/ex_unit/lib/ex_unit/filters.ex

@@ -12,24 +12,20 @@ defmodule ExUnit.Filters do
   @type location :: {:location, {String.t(), pos_integer | [pos_integer, ...]}}
   @type ex_unit_opts :: [exclude: [:test], include: [location, ...]] | []
 
-  @doc """
-  Parses filters out of a path.
-
-  Determines whether a given file path (supplied to ExUnit/Mix as arguments
-  on the command line) includes a line number filter, and if so returns the
-  appropriate ExUnit configuration options.
-  """
-  @spec parse_path(String.t()) :: {String.t(), ex_unit_opts}
-  # TODO: Deprecate this on Elixir v1.20
+  # TODO: Remove me on Elixir v2.0
+  @doc false
+  @deprecated "Use parse_paths/1 instead"
   def parse_path(file_path) do
     {[parsed_path], ex_unit_opts} = parse_paths([file_path])
     {parsed_path, ex_unit_opts}
   end
 
   @doc """
-  Like `parse_path/1` but for multiple paths.
+  Parses filters out of a path.
 
-  ExUnit filter options are combined.
+  Determines whether a given file path (supplied to ExUnit/Mix as arguments
+  on the command line) includes a line number filter, and if so returns the
+  appropriate ExUnit configuration options.
   """
   @spec parse_paths([String.t()]) :: {[String.t()], ex_unit_opts}
   def parse_paths(file_paths) do

lib/ex_unit/test/ex_unit/filters_test.exs

@@ -242,31 +242,33 @@ defmodule ExUnit.FiltersTest do
     for path <- [unix_path, windows_path, unix_path_with_dot] do
       fixed_path = path |> Path.split() |> Path.join() |> Path.relative_to_cwd()
 
-      assert ExUnit.Filters.parse_path("#{path}:123") ==
-               {fixed_path, [exclude: [:test], include: [location: {fixed_path, 123}]]}
+      assert ExUnit.Filters.parse_paths(["#{path}:123"]) ==
+               {[fixed_path], [exclude: [:test], include: [location: {fixed_path, 123}]]}
 
-      assert ExUnit.Filters.parse_path(path) == {fixed_path, []}
+      assert ExUnit.Filters.parse_paths([path]) == {[fixed_path], []}
 
-      assert ExUnit.Filters.parse_path("#{path}:123notreallyalinenumber123") ==
-               {"#{fixed_path}:123notreallyalinenumber123", []}
+      assert ExUnit.Filters.parse_paths(["#{path}:123notreallyalinenumber123"]) ==
+               {["#{fixed_path}:123notreallyalinenumber123"], []}
 
-      assert ExUnit.Filters.parse_path("#{path}:123:456") ==
-               {fixed_path, [exclude: [:test], include: [location: {fixed_path, [123, 456]}]]}
+      assert ExUnit.Filters.parse_paths(["#{path}:123:456"]) ==
+               {[fixed_path], [exclude: [:test], include: [location: {fixed_path, [123, 456]}]]}
 
-      assert ExUnit.Filters.parse_path("#{path}:123notalinenumber123:456") ==
-               {"#{fixed_path}:123notalinenumber123",
+      assert ExUnit.Filters.parse_paths(["#{path}:123notalinenumber123:456"]) ==
+               {["#{fixed_path}:123notalinenumber123"],
                 [
                   exclude: [:test],
                   include: [location: {"#{fixed_path}:123notalinenumber123", 456}]
                 ]}
 
       output =
         ExUnit.CaptureIO.capture_io(:stderr, fn ->
-          assert ExUnit.Filters.parse_path("#{path}:123:456notalinenumber456") ==
-                   {fixed_path, [{:exclude, [:test]}, {:include, [location: {fixed_path, 123}]}]}
+          assert ExUnit.Filters.parse_paths(["#{path}:123:456notalinenumber456"]) ==
+                   {[fixed_path],
+                    [{:exclude, [:test]}, {:include, [location: {fixed_path, 123}]}]}
 
-          assert ExUnit.Filters.parse_path("#{path}:123:0:-789:456") ==
-                   {fixed_path, [exclude: [:test], include: [location: {fixed_path, [123, 456]}]]}
+          assert ExUnit.Filters.parse_paths(["#{path}:123:0:-789:456"]) ==
+                   {[fixed_path],
+                    [exclude: [:test], include: [location: {fixed_path, [123, 456]}]]}
         end)
 
       assert output =~ "invalid line number given as ExUnit filter: 456notalinenumber456"

lib/ex_unit/test/test_helper.exs

@@ -2,8 +2,6 @@
 # SPDX-FileCopyrightText: 2021 The Elixir Team
 # SPDX-FileCopyrightText: 2012 Plataformatec
 
-Logger.configure_backend(:console, colors: [enabled: false])
-
 {line_exclude, line_include} =
   if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
 

lib/iex/lib/iex.ex

@@ -867,13 +867,4 @@ defmodule IEx do
 
   @doc false
   def dont_display_result, do: :"do not show this result in output"
-
-  ## CLI
-
-  # TODO: Remove me on Elixir v1.20+
-  @doc false
-  def start do
-    IO.warn("Use \"s iex\" instead")
-    :iex.start()
-  end
 end