Detecting Deprecated Regex Module Attributes in Elixir with Credo

Elixir 1.19 introduces a change that deprecates storing regular expressions (~r/.../) in module attributes. This is due to underlying changes in Erlang/OTP 28, which now emit references instead of binaries when compiling regexes. As a result, regexes stored in module attributes can no longer be inlined at compile time. While Elixir 1.19 includes a special-case workaround that recompiles injected regexes, this feature is now deprecated.

For teams maintaining large Elixir codebases, ensuring compatibility with this change before upgrading to Elixir 1.19 is crucial. A simple but effective way to detect deprecated usage is by leveraging Credo, the popular static code analysis tool for Elixir. This post introduces a custom Credo rule that scans for regex module attributes and issues warnings, helping developers identify those module attributes and get the codebase ready for when 1.19 gets released.

You can find out more about this change in the PR to Elixir: https://github.com/elixir-lang/elixir/pull/14381

Writing a custom credo check

Credo makes it easy to add custom checks: https://hexdocs.pm/credo/adding_checks.html

We can traverse the AST and match on individual attributes to detect module attributes with regular expressions.

I wrote a simple module that our Credo rule should catch and looked at the AST using Code.string_to_quoted:

source = """
defmodule Core.SomeModule do
  @some_regex ~r/foo/

  def some_function do
    IO.puts(@some_regex)
  end
end
"""

{:ok, ast} = Code.string_to_quoted(source)
IO.inspect(ast, pretty: true)

Yields the following AST:

{:defmodule, [line: 1],
 [
   {:__aliases__, [line: 1], [:Core, :SomeModule]},
   [
     do: {:__block__, [],
      [
        {:@, [line: 2],
         [
           {:some_regex, [line: 2],
            [
              {:sigil_r, [delimiter: "/", line: 2],
               [{:<<>>, [line: 2], ["foo"]}, []]}
            ]}
         ]},
        {:def, [line: 4],
         [
           {:some_function, [line: 4], nil},
           [
             do: {{:., [line: 5], [{:__aliases__, [line: 5], [:IO]}, :puts]},
              [line: 5], [{:@, [line: 5], [{:some_regex, [line: 5], nil}]}]}
           ]
         ]}
      ]}
   ]
 ]}

Now that we know the structure can use Credo's prewalk feature to traverse the AST and match on the node that defines the module attribute with :sigil_r in it:

defmodule Core.Checks.RegexModuleAttribute do
  @moduledoc """
  A custom Credo check that warns when a module attribute is assigned a regular expression.
  """
  use Credo.Check,
    base_priority: :normal,
    category: :warning,
    explanations: [
      check: """
      Elixir 1.19 deprecates regular expressions in module attributes. This check ensures
      your codebase is ready for the upcoming changes.
      """
    ]

  def run(source_file, params \\ []) do
    issue_meta = IssueMeta.for(source_file, params)
    Credo.Code.prewalk(source_file, &traverse(&1, &2, issue_meta))
  end

  defp traverse({:@, _, [{name, meta, [{:sigil_r, _, _}]} | _]} = ast, issues, issue_meta) do
    {ast, issues ++ [issue_for(name, meta[:line], issue_meta)]}
  end

  defp traverse(ast, issues, _issue_meta) do
    {ast, issues}
  end

  defp issue_for(name, line_no, issue_meta) do
    format_issue(
      issue_meta,
      message: "Avoid defining regular expressions in module attributes.",
      trigger: "@#{name}",
      line_no: line_no
    )
  end
end

When a node matches we simply add an issue to the issue_meta and include the line number. Credo will take care of properly formatting everything in the CLI for us.

We can also add a simple ExUnit test case to ensure the rule works properly:

defmodule Core.Checks.RegexModuleAttributeTest do
  use Credo.Test.Case

  alias Core.Checks.RegexModuleAttribute

  test "it should report a regex module attribute" do
    """
    defmodule Core.SomeModule do
      @some_regex ~r/foo/

      def some_function do
        IO.puts(@some_regex)
      end
    end
    """
    |> to_source_file()
    |> run_check(RegexModuleAttribute, [])
    |> assert_issue()
  end
end

How to Use the Credo Rule

Add the check to your .credo.exs configuration:

%{
  configs: [
    %{
      name: "default",
      checks: [
        {Core.Checks.RegexModuleAttribute, []}
      ]
    }
  ]
}

You can then run credo with: mix credo --strict

Conclusion

Elixir’s deprecation of regex module attributes is a necessary step to align with OTP 28. While the temporary workaround in Elixir 1.19 mitigates immediate breakage, the long-term solution is to remove regexes from module attributes entirely. By using a custom Credo rule, you can automate this detection and ensure a smooth transition. Happy coding!