ForgeCredoChecks

Custom Credo checks targeting Enum anti-patterns LLMs (and some humans) commonly produce in Elixir code.

Stock Credo ships rules for filter |> filter, reject |> reject, map |> join, etc. (same operation chained, or map terminating in a collector). It does not catch chains where one operation composes with the complementary one, or project-specific data-shape smells like Map.get/2 || fallback. These checks fill that gap.

Rules

Two-pass Enum chains: use a comprehension

Hand-rolled map building: use Map.new/2

Wasteful list-extremum patterns

with-macro conventions

Map shape normalization

LLM tells (function shape and idiomatic Elixir)

Typespec precision

Official Elixir anti-patterns

A few of the official Elixir anti-patterns that have a reliable AST signature. The rest of the catalog is either already covered by stock Credo (e.g. Warning.UnsafeToAtom, Refactor.FunctionArity, Refactor.WithClauses) or is too semantic to detect statically.

Architecture and test discipline

Boundary checks that enforce project structure rather than a language idiom.

The two-pass Enum chains walk the input twice and allocate intermediate lists; a comprehension does both in one pass and preserves order naturally. The map-building forms are pure equivalences with cleaner intent. The sort-then-pick patterns are O(N log N) when O(N) suffices. The with checks codify the convention that every clause uses <-, that step return shapes get normalized in helpers (so non-matches fall through), and that result tags stay within a project's intended vocabulary.

# Flagged by FilterMap
things
|> Enum.filter(&keep?/1)
|> Enum.map(&transform/1)

# Preferred replacement: comprehension (one pass, in-order, no reverse)
for x <- things, keep?(x), do: transform(x)

For the Enum-chain checks the suggested fix order is:

1. Comprehension (preferred). Single pass, preserves order, no intermediate list, no reverse step.
2. Enum.flat_map/2 when the transform is naturally 0-or-more (e.g. parse(x) returning nil-or-value).
3. Enum.reduce/3 only as a last resort, and only when the consumer does not care about order. Do not tack on |> Enum.reverse/1 to restore order: that second pass is exactly the tax the comprehension exists to avoid.

All Enum-chain rules detect the four AST shapes Elixir parses for any two-call chain: direct nested call, two-step pipe, partial pipe + call, and longer pipe chains.

Installation

Add to mix.exs:

def deps do
  [
    {:forge_credo_checks, "~> 0.7", only: [:dev, :test], runtime: false}
  ]
end

Then add to .credo.exs:

%{
  configs: [
    %{
      name: "default",
      checks: [
        # ...
        {ForgeCredoChecks.FilterMap, []},
        {ForgeCredoChecks.RejectMap, []},
        {ForgeCredoChecks.MapReject, []},
        {ForgeCredoChecks.MapRejectNil, []},
        {ForgeCredoChecks.MapNewFromInto, []},
        {ForgeCredoChecks.MapNewFromReduce, []},
        {ForgeCredoChecks.ReverseListFirst, []},
        {ForgeCredoChecks.SortListFirst, []},
        {ForgeCredoChecks.WithBareBinding, []},
        {ForgeCredoChecks.WithElseClauses, []},
        {ForgeCredoChecks.WithResultTag, []},
        {ForgeCredoChecks.InconsistentParamNames, []},
        {ForgeCredoChecks.NoKernelShadowing, []},
        {ForgeCredoChecks.NoUnnecessaryCatchAllRaise, []},
        {ForgeCredoChecks.NoCaseTrueFalse, []},
        {ForgeCredoChecks.NoKernelOpInPipeline, []},
        {ForgeCredoChecks.NoInlineRegex, []},
        {ForgeCredoChecks.NoAnyOrTermTypes, []},
        {ForgeCredoChecks.MapGetWithOr, []},
        {ForgeCredoChecks.ChainedMapGet, []},
        {ForgeCredoChecks.LargeStruct, []},
        {ForgeCredoChecks.UnsupervisedSpawn, []},
        {ForgeCredoChecks.NamespaceTrespassing, []},
        {ForgeCredoChecks.OneModulePerFile, []},
        {ForgeCredoChecks.TaintedSourceInspection, []},
        {ForgeCredoChecks.TimingAndPrivateStateGuard, []},
        {ForgeCredoChecks.MultilineStringConcat, []}
      ]
    }
  ]
}

License

MIT