Without cheating: defining __escape__/1

Author: sabiwara

lib/elixir/lib/kernel.ex

@@ -6648,8 +6648,7 @@ defmodule Kernel do
   defp compile_regex(binary_or_tuple, options) do
     bin_opts = :binary.list_to_bin(options)
 
-    # TODO: Remove this when we require Erlang/OTP 28.1+
-    case is_binary(binary_or_tuple) and compile_time_regexes_supported?() do
+    case is_binary(binary_or_tuple) do
       true ->
         Macro.escape(Regex.compile!(binary_or_tuple, bin_opts))
 
@@ -6658,14 +6657,6 @@ defmodule Kernel do
     end
   end
 
-  defp compile_time_regexes_supported? do
-    # OTP 28.0 introduced refs in patterns, which can't be used in AST anymore
-    # OTP 28.1 introduced :re.import/1 which allows us to fix this in Macro.escape
-    :erlang.system_info(:otp_release) < [?2, ?8] or
-      (Code.ensure_loaded?(:re) and
-         function_exported?(:re, :import, 1))
-  end
-
   @doc ~S"""
   Handles the sigil `~D` for dates.
 

lib/elixir/lib/regex.ex

@@ -1000,4 +1000,45 @@ defmodule Regex do
 
   defp translate_options(<<>>, acc), do: acc
   defp translate_options(t, _acc), do: {:error, t}
+
+  @doc false
+  def __escape__(%{__struct__: Regex} = regex) do
+    # OTP 28.0 introduced refs in patterns, which can't be used in AST anymore
+    # OTP 28.1 introduced :re.import/1 which allows us to work with pre-compiled binaries again
+
+    pattern_ast =
+      cond do
+        # TODO: Remove this when we require Erlang/OTP 28+
+        # Before OTP 28.0, patterns did not contain any refs and could be safely be escaped
+        :erlang.system_info(:otp_release) < [?2, ?8] ->
+          Macro.escape(regex.re_pattern)
+
+        # OTP 28.1+ introduced the ability to export and import regexes from compiled binaries
+        Code.ensure_loaded?(:re) and function_exported?(:re, :import, 1) ->
+          {:ok, exported} = :re.compile(regex.source, [:export] ++ regex.opts)
+
+          quote do
+            :re.import(unquote(Macro.escape(exported)))
+          end
+
+        # TODO: Remove this when we require Erlang/OTP 28.1+
+        # OTP 28.0 works in degraded mode performance-wise, we need to recompile from the source
+        true ->
+          quote do
+            {:ok, pattern} =
+              :re.compile(unquote(Macro.escape(regex.source)), unquote(Macro.escape(regex.opts)))
+
+            pattern
+          end
+      end
+
+    quote do
+      %{
+        __struct__: unquote(Regex),
+        re_pattern: unquote(pattern_ast),
+        source: unquote(Macro.escape(regex.source)),
+        opts: unquote(Macro.escape(regex.opts))
+      }
+    end
+  end
 end

lib/elixir/src/elixir_quote.erl

@@ -3,6 +3,9 @@
 %% SPDX-FileCopyrightText: 2012 Plataformatec
 
 -module(elixir_quote).
+
+-feature(maybe_expr, enable).
+
 -export([escape/3, linify/3, linify_with_context_counter/3, build/7, quote/2, has_unquotes/1, fun_to_quoted/1]).
 -export([dot/5, tail_list/3, list/2, validate_runtime/2, shallow_validate_ast/1]). %% Quote callbacks
 
@@ -168,28 +171,18 @@ do_escape(BitString, _) when is_bitstring(BitString) ->
       {'<<>>', [], [{'::', [], [Bits, {size, [], [Size]}]}, {'::', [], [Bytes, {binary, [], nil}]}]}
   end;
 
-do_escape(#{
-  '__struct__' := 'Elixir.Regex',
-  're_pattern' := {re_pattern, _, _, _, Ref},
-  'source' := Source,
-  'opts' := Opts
-} = Map, Q) when is_reference(Ref), is_binary(Source), is_list(Opts)  ->
-  case erlang:function_exported(re, import, 1) of
-    true ->
-      {ok, ExportedPattern} = re:compile(Source, [export | Opts]),
-      PatternAst = {{'.', [], ['re', 'import']}, [], [do_escape(ExportedPattern, Q)]},
-      {'%{}', [], [
-        {'__struct__', 'Elixir.Regex'},
-        {'re_pattern', PatternAst},
-        {'source', Source},
-        {'opts', do_escape(Opts, Q)}
-      ]};
-    false ->
-      escape_map(Map, Q)
-  end;
-
 do_escape(Map, Q) when is_map(Map) ->
-  escape_map(Map, Q);
+  maybe
+    #{'__struct__' := Module} ?= Map,
+    true ?= is_atom(Module),
+    {module, Module} ?= code:ensure_loaded(Module),
+    true ?= erlang:function_exported(Module, '__escape__', 1),
+    Module:'__escape__'(Map)
+  else
+    _ ->
+      TT = [escape_map_key_value(K, V, Map, Q) || {K, V} <- lists:sort(maps:to_list(Map))],
+      {'%{}', [], TT}
+  end;
 
 do_escape([], _) ->
   [];
@@ -222,10 +215,6 @@ do_escape(Fun, _) when is_function(Fun) ->
 do_escape(Other, _) ->
   bad_escape(Other).
 
-escape_map(Map, Q) ->
-  TT = [escape_map_key_value(K, V, Map, Q) || {K, V} <- lists:sort(maps:to_list(Map))],
-  {'%{}', [], TT}.
-
 escape_map_key_value(K, V, Map, Q) ->
   MaybeRef = if
     is_reference(V) -> V;
@@ -239,7 +228,7 @@ escape_map_key_value(K, V, Map, Q) ->
                         "(it must be defined within a function instead). ", (bad_escape_hint())/binary>>);
     true ->
       {do_quote(K, Q), do_quote(V, Q)}
-    end.
+  end.
 
 find_tuple_ref(Tuple, Index) when Index > tuple_size(Tuple) -> nil;
 find_tuple_ref(Tuple, Index) ->

lib/elixir/test/elixir/macro_test.exs

@@ -141,10 +141,9 @@ defmodule MacroTest do
       assert Macro.escape({:quote, [], [[do: :foo]]}) == {:{}, [], [:quote, [], [[do: :foo]]]}
     end
 
-    @tag skip: System.otp_release() < "28" or function_exported?(:re, :import, 1)
     test "escape container when a reference cannot be escaped" do
-      assert_raise ArgumentError, ~r"~r/foo/ contains a reference", fn ->
-        Macro.escape(%{~r/foo/ | re_pattern: {:re_pattern, 0, 0, 0, make_ref()}})
+      assert_raise ArgumentError, ~r"contains a reference", fn ->
+        Macro.escape(%{re_pattern: {:re_pattern, 0, 0, 0, make_ref()}})
       end
     end
 
@@ -160,7 +159,7 @@ defmodule MacroTest do
                  source: "foo",
                  opts: []
                ]
-             } = Macro.escape(%{~r/foo/ | re_pattern: {:re_pattern, 0, 0, 0, make_ref()}})
+             } = Macro.escape(~r/foo/)
     end
   end