Assert scope is not match/guard when using escaped regexes

lib/elixir/lib/regex.ex

@@ -1008,6 +1008,9 @@ defmodule Regex do
 
     pattern_ast =
       cond do
+        is_nil(regex.re_pattern) ->
+          nil
+
         # 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] ->
@@ -1018,7 +1021,8 @@ defmodule Regex do
           {:ok, exported} = :re.compile(regex.source, [:export] ++ regex.opts)
 
           quote do
-            :re.import(unquote(Macro.escape(exported)))
+            require Regex
+            Regex.__import_pattern__(unquote(Macro.escape(exported)))
           end
 
         # TODO: Remove this when we require Erlang/OTP 28.1+
@@ -1041,4 +1045,15 @@ defmodule Regex do
       }
     end
   end
+
+  @doc false
+  defmacro __import_pattern__(pattern) do
+    if __CALLER__.context in [:match, :guard] do
+      raise ArgumentError, "escaped"
+    end
+
+    quote do
+      :re.import(unquote(pattern))
+    end
+  end
 end

lib/elixir/test/elixir/macro_test.exs

@@ -167,8 +167,14 @@ defmodule MacroTest do
                [],
                [
                  __struct__: Regex,
-                 re_pattern:
-                   {{:., [], [:re, :import]}, [], [{:{}, [], [:re_exported_pattern | _]}]},
+                 re_pattern: {
+                   :__block__,
+                   [],
+                   [
+                     {:__assert_assert_no_match_or_guard_scope__, _, _},
+                     {{:., [], [:re, :import]}, [], [{:{}, [], [:re_exported_pattern | _]}]}
+                   ]
+                 },
                  source: "foo",
                  opts: []
                ]

lib/elixir/test/elixir/regex_test.exs

@@ -28,6 +28,25 @@ defmodule RegexTest do
     end
   end
 
+  @tag :re_import
+  test "module attribute in match context" do
+    assert_raise(
+      ArgumentError,
+      ~r/invalid expression in match, an escaped Regex is not allowed in patterns such as function clauses/,
+      fn ->
+        Code.eval_quoted(
+          quote do
+            defmodule ModAttrGuard do
+              @regex ~r/example/
+              def example?(@regex), do: true
+              def example?(_), do: false
+            end
+          end
+        )
+      end
+    )
+  end
+
   test "multiline" do
     refute Regex.match?(~r/^b$/, "a\nb\nc")
     assert Regex.match?(~r/^b$/m, "a\nb\nc")