Revert "Deprecate =~"

This reverts commit e42e3e5.

Author: José Valim

CHANGELOG.md

@@ -16,7 +16,6 @@
 * Deprecations
   * [Kernel] `binary_to_term/1`, `binary_to_term/2`, `term_to_binary/1` and `term_to_binary/2` are deprecated in favor of their counterparts in the `:erlang` module
   * [Kernel] `//` for default arguments is deprecated in favor of `\\`. This is a soft deprecation, no warnings will be emitted for it in this release
-  * [Kernel] Deprecate `=~` in favor of `String.contains?/2` (for strings) and `String.match?/2` (for regexes)
   * [Kernel] Deprecate `@behavior` in favor of `@behaviour`
   * [Record] Deprecate `to_keywords`, `getter` and `list getter` functionalities in `defrecordp`
 

lib/elixir/lib/kernel.ex

@@ -1789,15 +1789,32 @@ defmodule Kernel do
     end
   end
 
-  @doc false
+  @doc """
+  Matches the term on the left against the regular expression or string on the
+  right. Returns true if `left` matches `right` (if it's a regular expression)
+  or contains `right` (if it's a string).
+
+  ## Examples
+
+      iex> "abcd" =~ %r/c(d)/
+      true
+
+      iex> "abcd" =~ %r/e/
+      false
+
+      iex> "abcd" =~ "bc"
+      true
+
+      iex> "abcd" =~ "ad"
+      false
+
+  """
   def left =~ right when is_binary(left) and is_binary(right) do
-    IO.write :stderr, "left =~ right is deprecated, please use String.match?/2 (for regexes) or String.contains?/2 (for strings) instead\n#{Exception.format_stacktrace}"
     :binary.match(left, right) != :nomatch
   end
 
   def left =~ right when is_binary(left) and is_tuple(right) and
       tuple_size(right) > 0 and elem(right, 0) == Regex do
-    IO.write :stderr, "left =~ right is deprecated, please use String.match?/2 (for regexes) or String.contains?/2 (for strings) instead\n#{Exception.format_stacktrace}"
     Regex.match?(right, left)
   end
 

lib/elixir/lib/version.ex

@@ -363,7 +363,7 @@ defmodule Version do
     @spec parse_pre(String.t) :: [String.t | integer]
     def parse_pre(pre) do
       String.split(pre, ".") |> Enum.map fn piece ->
-        if Regex.match?(%r/^(0|[1-9][0-9]*)$/, piece) do
+        if piece =~ %r/^(0|[1-9][0-9]*)$/ do
           binary_to_integer(piece)
         else
           piece

lib/elixir/test/elixir/exception_test.exs

@@ -47,8 +47,8 @@ defmodule Kernel.ExceptionTest do
     assert Exception.format_stacktrace_entry({:lists, :bar, [1, 2, 3], []}) == "(stdlib) :lists.bar(1, 2, 3)"  end
 
   test "format_stacktrace_entry with fun" do
-    assert String.match? Exception.format_stacktrace_entry({fn(x) -> x end, [1], []}), %r/#Function<.+>\(1\)/
-    assert String.match? Exception.format_stacktrace_entry({fn(x, y) -> { x, y } end, 2, []}), %r"#Function<.+>/2"
+    assert Exception.format_stacktrace_entry({fn(x) -> x end, [1], []}) =~ %r/#Function<.+>\(1\)/
+    assert Exception.format_stacktrace_entry({fn(x, y) -> { x, y } end, 2, []}) =~ %r"#Function<.+>/2"
   end
 
   test "format_mfa" do
@@ -61,7 +61,7 @@ defmodule Kernel.ExceptionTest do
   end
 
   test "format_fa" do
-    assert String.match? Exception.format_fa(fn -> end, 1),
+    assert Exception.format_fa(fn -> end, 1) =~
            %r"#Function<\d\.\d+/0 in Kernel\.ExceptionTest\.test format_fa/1>/1"
   end
 

lib/elixir/test/elixir/hash_dict_test.exs

@@ -49,7 +49,7 @@ defmodule HashDictTest do
   end
 
   test "inspect" do
-    assert String.starts_with? inspect(filled_dict(8)), "#HashDict<"
+    assert inspect(filled_dict(8)) =~ "#HashDict<"
   end
 
   defp smoke_test(range) do

lib/elixir/test/elixir/kernel/cli_test.exs

@@ -87,18 +87,18 @@ defmodule Kernel.CLI.ParallelCompilerTest do
 
   test "compiles files solving dependencies" do
     fixtures = [fixture_path("parallel_compiler/bar.ex"), fixture_path("parallel_compiler/foo.ex")]
-    assert String.contains? capture_io(fn ->
+    assert capture_io(fn ->
       assert [Bar, Foo] = Kernel.ParallelCompiler.files fixtures
-    end), "message_from_foo"
+    end) =~ "message_from_foo"
   end
 
   test "does not hang on missing dependencies" do
     fixtures = [fixture_path("parallel_compiler/bat.ex")]
-    assert String.contains? capture_io(fn ->
+    assert capture_io(fn ->
       assert_raise CompileError, fn ->
         Kernel.ParallelCompiler.files fixtures
       end
-    end), "Compilation error"
+    end) =~ "Compilation error"
   end
 
   test "handles possible deadlocks" do
@@ -110,8 +110,8 @@ defmodule Kernel.CLI.ParallelCompilerTest do
       end
     end)
 
-    assert String.contains? msg, "* #{fixture_path "parallel_deadlock/foo.ex"} is missing module Bar"
-    assert String.contains? msg, "* #{fixture_path "parallel_deadlock/bar.ex"} is missing module Foo"
+    assert msg =~ "* #{fixture_path "parallel_deadlock/foo.ex"} is missing module Bar"
+    assert msg =~ "* #{fixture_path "parallel_deadlock/bar.ex"} is missing module Foo"
   end
 
   test "warnings_as_errors" do

lib/elixir/test/elixir/kernel/expansion_test.exs

@@ -153,8 +153,8 @@ defmodule Kernel.ExpansionTest do
   ## Locals
 
   test "locals: expands to remote calls" do
-    assert { {:., _, [Kernel, :function_exported?] }, _, [{:a, _, []}, {:b, _, []}, {:c, _, []}] } =
-          expand(quote do: function_exported?(a, b, c))
+    assert { {:., _, [Kernel, :=~] }, _, [{:a, _, []}, {:b, _, []}] } =
+          expand(quote do: a =~ b)
   end
 
   test "locals: expands to configured local" do