     case Macro.expand(message, __CALLER__) do
       message when is_binary(message) ->
         quote do
-          :erlang.raise :error, RuntimeError.exception(unquote(message)), unquote(stacktrace)
+          :erlang.raise(:error, RuntimeError.exception(unquote(message)), unquote(stacktrace))
         end
+
       {:<<>>, _, _} = message ->
         quote do
-          :erlang.raise :error, RuntimeError.exception(unquote(message)), unquote(stacktrace)
+          :erlang.raise(:error, RuntimeError.exception(unquote(message)), unquote(stacktrace))
         end
+
       alias when is_atom(alias) ->
         quote do
-          :erlang.raise :error, unquote(alias).exception([]), unquote(stacktrace)
+          :erlang.raise(:error, unquote(alias).exception([]), unquote(stacktrace))
         end
+
       message ->
         quote do
           stacktrace = unquote(stacktrace)
+
           case unquote(message) do
             message when is_binary(message) ->
-              :erlang.raise :error, RuntimeError.exception(message), stacktrace
+              :erlang.raise(:error, RuntimeError.exception(message), stacktrace)
+
             atom when is_atom(atom) ->
-              :erlang.raise :error, atom.exception([]), stacktrace
+              :erlang.raise(:error, atom.exception([]), stacktrace)
+
             %_{__exception__: true} = other ->
-              :erlang.raise :error, other, stacktrace
+              :erlang.raise(:error, other, stacktrace)
+
             other ->
-              message = "reraise/2 expects a module name, string or exception as the first argument, got: #{inspect other}"
-              :erlang.error ArgumentError.exception(message)
+              message = <<
+                "reraise/2 expects a module name, string or exception",
+                "as the first argument, got: #{inspect(other)}"
+              >>
+
+              :erlang.error(ArgumentError.exception(message))
           end
         end
     end

    # are not messed up. Basically, we just insert something between the return
    # value of the block and what is returned by defmodule. Using just ":ok" or
    # similar doesn't work because it's likely optimized away by the compiler.
    block = quote do
      result = unquote(block)
      :elixir_utils.noop()
      result
    end

    escaped =
      case env do
        %{function: nil, lexical_tracker: pid} when is_pid(pid) ->
          integer = Kernel.LexicalTracker.write_cache(pid, block)
          quote do: Kernel.LexicalTracker.read_cache(unquote(pid), unquote(integer))
        %{} ->
          {escaped, _} = :elixir_quote.escape(block, false)
          escaped


  """
  defmacro sigil_r(term, modifiers)

  defmacro sigil_r({:<<>>, _meta, [string]}, options) when is_binary(string) do
    binary = :elixir_interpolation.unescape_chars(string, &Regex.unescape_map/1)
    regex = Regex.compile!(binary, :binary.list_to_bin(options))
    Macro.escape(regex)
  end

  defmacro sigil_r({:<<>>, meta, pieces}, options) do
    binary = {:<<>>, meta, :elixir_interpolation.unescape_tokens(pieces, &Regex.unescape_map/1)}
    quote(do: Regex.compile!(unquote(binary), unquote(:binary.list_to_bin(options))))
  end

  @doc ~S"""
