Release 0.8.0

Author: dannote

.github/workflows/release.yml

@@ -36,7 +36,7 @@ jobs:
         with:
           target: ${{ matrix.job.target }}
 
-      - name: Build the project
+      - name: Build oxc_ex_nif
         id: build-crate
         uses: philss/rustler-precompiled-action@v1.1.4
         with:
@@ -48,14 +48,35 @@ jobs:
           project-dir: "."
           cross-version: "from-source"
 
+      - name: Build oxc_lint_nif
+        if: matrix.job.target != 'x86_64-unknown-linux-musl'
+        id: build-lint-crate
+        uses: philss/rustler-precompiled-action@v1.1.4
+        with:
+          project-name: oxc_lint_nif
+          project-version: ${{ env.PROJECT_VERSION }}
+          target: ${{ matrix.job.target }}
+          nif-version: ${{ matrix.nif }}
+          use-cross: ${{ matrix.job.use-cross }}
+          project-dir: "native/oxc_lint_nif"
+          cross-version: "from-source"
+
       - name: Artifact upload
         uses: actions/upload-artifact@v4
         with:
           name: ${{ steps.build-crate.outputs.file-name }}
           path: ${{ steps.build-crate.outputs.file-path }}
 
+      - name: Artifact upload (lint)
+        if: matrix.job.target != 'x86_64-unknown-linux-musl'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ steps.build-lint-crate.outputs.file-name }}
+          path: ${{ steps.build-lint-crate.outputs.file-path }}
+
       - name: Publish archives and packages
         uses: softprops/action-gh-release@v2
         with:
           files: |
             ${{ steps.build-crate.outputs.file-path }}
+            ${{ steps.build-lint-crate.outputs.file-path }}

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.8.0
+
+### Added
+
+- `OXC.Lint.run/3` — lint JS/TS source with oxlint's 650+ built-in rules via a Rust NIF. Supports all oxlint plugins (react, typescript, unicorn, import, jsdoc, jest, vitest, jsx-a11y, nextjs, promise, node, vue) and configurable rule severities.
+- `OXC.Lint.Rule` behaviour — write custom lint rules in Elixir that operate on the parsed ESTree AST. Rules use `OXC.walk/2`, `OXC.collect/2`, or `OXC.postwalk/3` for traversal and return diagnostics with spans.
+- Built-in and custom rules run together in a single `OXC.Lint.run/3` call.
+
 ## 0.7.2
 
 ### Added

checksum-Elixir.OXC.Lint.Native.exs

@@ -0,0 +1,2 @@
+%{
+}

lib/oxc/lint.ex

@@ -0,0 +1,124 @@
+defmodule OXC.Lint do
+  @moduledoc """
+  Lint JavaScript/TypeScript source with oxlint's built-in rules
+  and optional custom Elixir rules.
+
+  Combines native Rust performance for 650+ standard rules with
+  the ability to write project-specific rules in Elixir using
+  the same AST that `OXC.parse/2` returns.
+
+  ## Examples
+
+      {:ok, diags} = OXC.Lint.run("debugger;", "test.js",
+        rules: %{"no-debugger" => :deny})
+
+      {:ok, []} = OXC.Lint.run("export const x = 1;\\n", "test.ts")
+  """
+
+  @type severity :: :allow | :warn | :deny
+  @type diagnostic :: %{
+          rule: String.t(),
+          message: String.t(),
+          severity: severity(),
+          span: {non_neg_integer(), non_neg_integer()},
+          labels: [{non_neg_integer(), non_neg_integer()}],
+          help: String.t() | nil
+        }
+
+  @doc """
+  Lint source code with oxlint's built-in rules and optional custom rules.
+
+  ## Options
+
+    * `:rules` — map of rule names to severity (`:deny`, `:warn`, `:allow`).
+      Rule names follow oxlint conventions: `"eqeqeq"`, `"react/no-danger"`,
+      `"typescript/no-explicit-any"`, etc.
+
+    * `:plugins` — list of built-in plugin atoms to enable.
+      Default: oxlint defaults (eslint correctness rules).
+      Available: `:react`, `:typescript`, `:unicorn`, `:import`, `:jsdoc`,
+      `:jest`, `:vitest`, `:jsx_a11y`, `:nextjs`, `:react_perf`, `:promise`,
+      `:node`, `:vue`, `:oxc`
+
+    * `:fix` — compute fix suggestions. Default: `false`
+
+    * `:custom_rules` — list of `{module, severity}` tuples for Elixir rules.
+      Each module must implement the `OXC.Lint.Rule` behaviour.
+
+    * `:settings` — arbitrary map passed to custom rule context.
+
+  ## Examples
+
+      # Built-in rules only
+      {:ok, diags} = OXC.Lint.run("debugger;", "test.js",
+        rules: %{"no-debugger" => :deny})
+
+      # With specific plugins and rules
+      {:ok, diags} = OXC.Lint.run(source, "app.tsx",
+        plugins: [:react, :typescript],
+        rules: %{"no-console" => :warn, "react/no-danger" => :deny}
+      )
+
+      # With custom Elixir rules
+      {:ok, diags} = OXC.Lint.run(source, "app.ts",
+        custom_rules: [{MyApp.NoConsoleLog, :warn}]
+      )
+  """
+  @spec run(String.t(), String.t(), keyword()) :: {:ok, [diagnostic()]} | {:error, [String.t()]}
+  def run(source, filename, opts \\ []) do
+    plugins = opts |> Keyword.get(:plugins, []) |> Enum.map(&to_string/1)
+    fix = Keyword.get(opts, :fix, false)
+
+    rules =
+      opts
+      |> Keyword.get(:rules, %{})
+      |> Enum.map(fn {name, severity} -> {to_string(name), severity_to_string(severity)} end)
+
+    custom_rules = Keyword.get(opts, :custom_rules, [])
+    settings = Keyword.get(opts, :settings, %{})
+
+    case OXC.Lint.Native.lint(source, filename, plugins, rules, fix) do
+      {:ok, builtin_diags} ->
+        custom =
+          case custom_rules do
+            [] -> []
+            rules -> run_custom_rules(rules, source, filename, settings)
+          end
+
+        {:ok, builtin_diags ++ custom}
+
+      {:error, errors} ->
+        {:error, errors}
+    end
+  end
+
+  defp severity_to_string(:deny), do: "deny"
+  defp severity_to_string(:warn), do: "warn"
+  defp severity_to_string(:allow), do: "allow"
+
+  defp run_custom_rules(rules, source, filename, settings) do
+    case OXC.parse(source, filename) do
+      {:ok, ast} ->
+        context = %{source: source, filename: filename, settings: settings}
+
+        Enum.flat_map(rules, fn {module, severity} ->
+          meta = module.meta()
+
+          module.run(ast, context)
+          |> Enum.map(fn diag ->
+            %{
+              rule: meta.name,
+              message: diag.message,
+              severity: severity,
+              span: Map.get(diag, :span, {0, 0}),
+              labels: Map.get(diag, :labels, []),
+              help: Map.get(diag, :help)
+            }
+          end)
+        end)
+
+      {:error, _} ->
+        []
+    end
+  end
+end

lib/oxc/lint/native.ex

@@ -0,0 +1,28 @@
+defmodule OXC.Lint.Native do
+  @moduledoc false
+
+  version = Mix.Project.config()[:version]
+  source_root = Path.expand("../../..", __DIR__)
+
+  local_test_build =
+    Mix.env() == :test and
+      File.exists?(Path.join(source_root, "test/test_helper.exs")) and
+      File.dir?(Path.join(source_root, ".git"))
+
+  use RustlerPrecompiled,
+    otp_app: :oxc,
+    crate: "oxc_lint_nif",
+    base_url: "https://github.com/elixir-volt/oxc_ex/releases/download/v#{version}",
+    force_build: local_test_build or System.get_env("OXC_EX_BUILD") in ["1", "true"],
+    targets: ~w(
+      aarch64-apple-darwin
+      aarch64-unknown-linux-gnu
+      x86_64-apple-darwin
+      x86_64-unknown-linux-gnu
+    ),
+    version: version
+
+  @spec lint(String.t(), String.t(), [String.t()], [{String.t(), String.t()}], boolean()) ::
+          {:ok, [map()]} | {:error, [String.t()]}
+  def lint(_source, _filename, _plugins, _rules, _fix), do: :erlang.nif_error(:nif_not_loaded)
+end

lib/oxc/lint/rule.ex

@@ -0,0 +1,70 @@
+defmodule OXC.Lint.Rule do
+  @moduledoc """
+  Behaviour for custom lint rules in Elixir.
+
+  Rules receive the parsed ESTree AST (from `OXC.parse/2`) and return
+  diagnostics. Use `OXC.walk/2`, `OXC.collect/2`, or `OXC.postwalk/3`
+  for traversal.
+
+  ## Example
+
+      defmodule MyApp.NoConsoleLog do
+        @behaviour OXC.Lint.Rule
+
+        @impl true
+        def meta do
+          %{
+            name: "my-app/no-console-log",
+            description: "Disallow console.log in production code",
+            category: :restriction,
+            fixable: false
+          }
+        end
+
+        @impl true
+        def run(ast, _context) do
+          OXC.collect(ast, fn
+            %{
+              type: :call_expression,
+              callee: %{
+                type: :member_expression,
+                object: %{type: :identifier, name: "console"},
+                property: %{type: :identifier, name: "log"}
+              },
+              start: start,
+              end: stop
+            } ->
+              {:keep, %{span: {start, stop}, message: "Unexpected console.log"}}
+
+            _ ->
+              :skip
+          end)
+        end
+      end
+  """
+
+  @type meta :: %{
+          name: String.t(),
+          description: String.t(),
+          category:
+            :correctness | :suspicious | :pedantic | :perf | :style | :restriction | :nursery,
+          fixable: boolean()
+        }
+
+  @type context :: %{
+          source: String.t(),
+          filename: String.t(),
+          settings: map()
+        }
+
+  @type diagnostic :: %{
+          required(:span) => {non_neg_integer(), non_neg_integer()},
+          required(:message) => String.t(),
+          optional(:help) => String.t() | nil,
+          optional(:labels) => [{non_neg_integer(), non_neg_integer()}],
+          optional(:fix) => String.t() | nil
+        }
+
+  @callback meta() :: meta()
+  @callback run(ast :: map(), context :: context()) :: [diagnostic()]
+end

mix.exs

@@ -1,7 +1,7 @@
 defmodule OXC.MixProject do
   use Mix.Project
 
-  @version "0.7.2"
+  @version "0.8.0"
   @source_url "https://github.com/elixir-volt/oxc_ex"
 
   def project do
@@ -37,7 +37,7 @@ defmodule OXC.MixProject do
         "OXC" => "https://oxc.rs"
       },
       files:
-        ~w(lib native/oxc_ex_nif/src native/oxc_ex_nif/Cargo.toml Cargo.toml Cargo.lock .formatter.exs mix.exs README.md LICENSE checksum-*.exs)
+        ~w(lib native/oxc_ex_nif/src native/oxc_ex_nif/Cargo.toml native/oxc_lint_nif/src native/oxc_lint_nif/Cargo.toml native/oxc_lint_nif/Cargo.lock Cargo.toml Cargo.lock .formatter.exs mix.exs README.md LICENSE checksum-*.exs)
     ]
   end
 

native/oxc_ex_nif/src/parse.rs

@@ -82,9 +82,8 @@ impl TransformOutput {
                 }),
             )
                 .encode(env),
-            TransformOutput::Error(errors) => {
-                crate::error::error_to_term(env, errors).unwrap_or_else(|_| atoms::error().encode(env))
-            }
+            TransformOutput::Error(errors) => crate::error::error_to_term(env, errors)
+                .unwrap_or_else(|_| atoms::error().encode(env)),
         }
     }
 }
@@ -163,10 +162,7 @@ pub fn parse<'a>(env: Env<'a>, source: &str, filename: &str) -> NifResult<Term<'
     let json: Value = match deserializer.into_iter().next() {
         Some(Ok(v)) => v,
         Some(Err(e)) => {
-            return error_to_term(
-                env,
-                &[format!("Failed to deserialize ESTree JSON: {e}")],
-            )
+            return error_to_term(env, &[format!("Failed to deserialize ESTree JSON: {e}")])
         }
         None => return error_to_term(env, &["Empty ESTree JSON output".to_string()]),
     };

native/oxc_lint_nif/.gitignore

@@ -0,0 +1 @@
+/target