Support Erlang/OTP 28

Author: josevalim

lib/elixir/lib/regex.ex

@@ -209,17 +209,14 @@ defmodule Regex do
 
   ## Examples
 
-      iex> Regex.compile("foo")
-      {:ok, ~r/foo/}
+      Regex.compile("foo")
+      #=> {:ok, ~r/foo/}
 
-      iex> Regex.compile("*foo")
-      {:error, {~c"nothing to repeat", 0}}
+      Regex.compile("foo", "i")
+      #=>{:ok, ~r/foo/i}
 
-      iex> Regex.compile("foo", "i")
-      {:ok, ~r/foo/i}
-
-      iex> Regex.compile("foo", [:caseless])
-      {:ok, Regex.compile!("foo", [:caseless])}
+      Regex.compile("*foo")
+      #=> {:error, {~c"nothing to repeat", 0}}
 
   """
   @spec compile(binary, binary | [term]) :: {:ok, t} | {:error, term}

lib/elixir/src/elixir_erl.erl

@@ -165,7 +165,12 @@ dynamic_form(#{module := Module, relative_file := RelativeFile,
   {Def, Defmacro, Macros, Exports, Functions} =
     split_definition(Definitions, Unreachable, Line, [], [], [], [], {[], []}),
 
-  FilteredOpts = lists:filter(fun({no_warn_undefined, _}) -> false; (_) -> true end, Opts),
+  FilteredOpts = lists:filter(fun(
+    {no_warn_undefined, _}) -> false;
+    (debug_info) -> false;
+    (_) -> true
+  end, Opts),
+
   Location = {elixir_utils:characters_to_list(RelativeFile), Line},
 
   Prefix = [{attribute, Line, file, Location},

lib/elixir/test/elixir/fixtures/dialyzer/protocol_opaque.ex

@@ -119,23 +119,6 @@ defmodule Kernel.DialyzerTest do
     assert_dialyze_no_warnings!(context)
   end
 
-  @tag warnings: [:specdiffs]
-  test "no warnings on protocol calls with opaque types", context do
-    alias Dialyzer.ProtocolOpaque
-
-    copy_beam!(context, ProtocolOpaque)
-    copy_beam!(context, ProtocolOpaque.Entity)
-    copy_beam!(context, ProtocolOpaque.Entity.Any)
-    copy_beam!(context, ProtocolOpaque.Duck)
-    assert_dialyze_no_warnings!(context)
-
-    # Also ensure no warnings after consolidation.
-    Code.prepend_path(context.base_dir)
-    {:ok, binary} = Protocol.consolidate(ProtocolOpaque.Entity, [ProtocolOpaque.Duck, Any])
-    File.write!(Path.join(context.outdir, "#{ProtocolOpaque.Entity}.beam"), binary)
-    assert_dialyze_no_warnings!(context)
-  end
-
   test "no warnings on and/2 and or/2", context do
     copy_beam!(context, Dialyzer.BooleanCheck)
     assert_dialyze_no_warnings!(context)

lib/elixir/test/elixir/kernel/dialyzer_test.exs

@@ -428,10 +428,9 @@ end
 defmodule OptionsParserDeprecationsTest do
   use ExUnit.Case, async: true
 
-  @warning ~r[not passing the :switches or :strict option to OptionParser is deprecated]
-
   def assert_deprecated(fun) do
-    assert ExUnit.CaptureIO.capture_io(:stderr, fun) =~ @warning
+    assert ExUnit.CaptureIO.capture_io(:stderr, fun) =~
+             "not passing the :switches or :strict option to OptionParser is deprecated"
   end
 
   test "parses boolean option" do

lib/elixir/test/elixir/option_parser_test.exs

@@ -3,39 +3,6 @@ Code.require_file("test_helper.exs", __DIR__)
 defmodule RegexTest do
   use ExUnit.Case, async: true
 
-  @re_21_3_little %Regex{
-    re_pattern:
-      {:re_pattern, 1, 0, 0,
-       <<69, 82, 67, 80, 94, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255,
-         255, 99, 0, 0, 0, 0, 0, 1, 0, 0, 0, 64, 0, 6, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 102, 111, 111, 0, 131, 0, 20, 29, 99, 133,
-         0, 7, 0, 1, 29, 100, 119, 0, 5, 29, 101, 120, 0, 12, 120, 0, 20, 0>>},
-    re_version: {"8.42 2018-03-20", :little},
-    source: "c(?<foo>d|e)"
-  }
-
-  @re_21_3_big %Regex{
-    re_pattern:
-      {:re_pattern, 1, 0, 0,
-       <<80, 67, 82, 69, 0, 0, 0, 86, 0, 0, 0, 0, 0, 0, 0, 17, 255, 255, 255, 255, 255, 255, 255,
-         255, 0, 99, 0, 0, 0, 0, 0, 1, 0, 0, 0, 56, 0, 6, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-         0, 0, 0, 0, 0, 0, 1, 102, 111, 111, 0, 131, 0, 20, 29, 99, 133, 0, 7, 0, 1, 29, 100, 119,
-         0, 5, 29, 101, 120, 0, 12, 120, 0, 20, 0>>},
-    re_version: {"8.42 2018-03-20", :big},
-    source: "c(?<foo>d|e)"
-  }
-
-  @re_19_3_little %Regex{
-    re_pattern:
-      {:re_pattern, 1, 0, 0,
-       <<69, 82, 67, 80, 94, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255,
-         255, 99, 0, 0, 0, 0, 0, 1, 0, 0, 0, 64, 0, 6, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 102, 111, 111, 0, 125, 0, 20, 29, 99, 127,
-         0, 7, 0, 1, 29, 100, 113, 0, 5, 29, 101, 114, 0, 12, 114, 0, 20, 0>>},
-    re_version: {"8.33 2013-05-29", :little},
-    source: "c(?<foo>d|e)"
-  }
-
   doctest Regex
 
   test "multiline" do
@@ -68,16 +35,9 @@ defmodule RegexTest do
   test "literal source" do
     assert Regex.source(Regex.compile!("foo")) == "foo"
     assert Regex.source(~r"foo") == "foo"
-    assert Regex.re_pattern(Regex.compile!("foo")) == Regex.re_pattern(~r"foo")
 
     assert Regex.source(Regex.compile!("\a\b\d\e\f\n\r\s\t\v")) == "\a\b\d\e\f\n\r\s\t\v"
     assert Regex.source(~r<\a\b\d\e\f\n\r\s\t\v>) == "\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v"
-
-    assert Regex.re_pattern(Regex.compile!("\a\b\d\e\f\n\r\s\t\v")) ==
-             Regex.re_pattern(~r"\x07\x08\x7F\x1B\x0C\x0A\x0D\x20\x09\x0B")
-
-    assert Regex.re_pattern(Regex.compile!("\\a\\b\\d\e\f\\n\\r\\s\\t\\v")) ==
-             Regex.re_pattern(~r"\a\b\d\e\f\n\r\s\t\v")
   end
 
   test "Unicode" do
@@ -116,16 +76,6 @@ defmodule RegexTest do
     end
   end
 
-  test "recompile/1" do
-    new_regex = ~r/foo/
-    {:ok, %Regex{}} = Regex.recompile(new_regex)
-    assert %Regex{} = Regex.recompile!(new_regex)
-
-    old_regex = Map.delete(~r/foo/, :re_version)
-    {:ok, %Regex{}} = Regex.recompile(old_regex)
-    assert %Regex{} = Regex.recompile!(old_regex)
-  end
-
   test "opts/1" do
     assert Regex.opts(Regex.compile!("foo", "i")) == [:caseless]
     assert Regex.opts(Regex.compile!("foo", [:ucp])) == [:ucp]
@@ -179,16 +129,6 @@ defmodule RegexTest do
     assert Regex.run(~r"bar", "foobar", offset: 2, return: :index) == [{3, 3}]
   end
 
-  test "run/3 with regexes compiled in different systems" do
-    assert Regex.run(@re_21_3_little, "abcd abce", capture: :all_names) == ["d"]
-    assert Regex.run(@re_21_3_big, "abcd abce", capture: :all_names) == ["d"]
-    assert Regex.run(@re_19_3_little, "abcd abce", capture: :all_names) == ["d"]
-  end
-
-  test "run/3 with regexes with options compiled in different systems" do
-    assert Regex.run(%{~r/foo/i | re_version: "bad version"}, "FOO") == ["FOO"]
-  end
-
   test "scan/2" do
     assert Regex.scan(~r"c(d|e)", "abcd abce") == [["cd", "d"], ["ce", "e"]]
     assert Regex.scan(~r"c(?:d|e)", "abcd abce") == [["cd"], ["ce"]]
@@ -207,16 +147,6 @@ defmodule RegexTest do
     assert Regex.scan(~r"^foo", "foobar", offset: 1) == []
   end
 
-  test "scan/2 with regexes compiled in different systems" do
-    assert Regex.scan(@re_21_3_little, "abcd abce", capture: :all_names) == [["d"], ["e"]]
-    assert Regex.scan(@re_21_3_big, "abcd abce", capture: :all_names) == [["d"], ["e"]]
-    assert Regex.scan(@re_19_3_little, "abcd abce", capture: :all_names) == [["d"], ["e"]]
-  end
-
-  test "scan/2 with regexes with options compiled in different systems" do
-    assert Regex.scan(%{~r/foo/i | re_version: "bad version"}, "FOO") == [["FOO"]]
-  end
-
   test "split/2,3" do
     assert Regex.split(~r",", "") == [""]
     assert Regex.split(~r",", "", trim: true) == []

lib/elixir/test/elixir/regex_test.exs

@@ -707,7 +707,7 @@ defmodule ExUnit.AssertionsTest do
     rescue
       error in [ExUnit.AssertionError] ->
         "foo" = error.left
-        ~r{a} = error.right
+        %Regex{} = error.right
     end
   end
 
@@ -722,7 +722,7 @@ defmodule ExUnit.AssertionsTest do
     rescue
       error in [ExUnit.AssertionError] ->
         "foo" = error.left
-        ~r"o" = error.right
+        %Regex{} = error.right
     end
   end
 

lib/ex_unit/test/ex_unit/assertions_test.exs

@@ -349,7 +349,7 @@ defmodule IEx.HelpersTest do
         assert captured =~ "-spec sleep(Time) -> ok when Time :: timeout()."
       else
         assert captured =~ "sleep(Time)"
-        assert captured =~ "@spec sleep(time) :: :ok when time: timeout()"
+        assert captured =~ "@spec sleep(time) :: :ok when time: "
       end
     end