release v0.26.9

Problem: Offsets such as parse_table, symbol_names, lex_modes, and the alias/supertype tables are used directly as indexes into the store's memory buffer. A malformed module can point one of those fields outside the current linear memory and make the host process read through an invalid pointer while loading the language.

Solution: Add a small checked-memory wrapper for Wasm language loading and routes descriptor reads, table copies, string reads, and the alias-map scan through it. Invalid descriptor addresses now fail loading with TSWasmErrorKindInstantiate.

(cherry picked from commit 21cfae7b56)

Co-authored-by: 𝙽!𝙻 <z_hakmi@estin.dz>

.dockerignore

@@ -0,0 +1,2 @@
+target
+.git

.envrc

@@ -1,4 +1 @@
-source_up_if_exists
-if [ -z "${IN_NIX_SHELL:-}" ]; then
-  use flake .
-fi
+use flake

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -2,14 +2,6 @@ name: Bug Report
 description: Report a problem
 type: Bug
 body:
-  - type: checkboxes
-    attributes:
-      label: AI Policy
-      description: Review our [AI Policy](https://tree-sitter.github.io/tree-sitter/6-contributing.html#ai-policy).
-      options:
-        - label: I have read the AI Policy and this issue complies with it.
-          required: true
-
   - type: textarea
     attributes:
       label: "Problem"

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -2,14 +2,6 @@ name: Feature request
 description: Request an enhancement
 type: Feature
 body:
-  - type: checkboxes
-    attributes:
-      label: AI Policy
-      description: Review our [AI Policy](https://tree-sitter.github.io/tree-sitter/6-contributing.html#ai-policy).
-      options:
-        - label: I have read the AI Policy and this issue complies with it.
-          required: true
-
   - type: markdown
     attributes:
       value: |

.github/actions/cache/action.yml

@@ -21,9 +21,6 @@ runs:
           'lib/src/parser.h',
           'lib/src/array.h',
           'lib/src/alloc.h',
-          'lib/src/wasm-stdlib/external_scanner_stdlib.h',
-          'crates/loader/wasi-sdk-version',
-          'crates/loader/binaryen-version',
           'test/fixtures/grammars/*/**/src/*.c',
           'test/fixtures/fixtures.json',
           '.github/actions/cache/action.yml') }}

.github/cliff.toml

@@ -43,16 +43,16 @@ commit_preprocessors = [
 ]
 # regex for parsing and grouping commits
 commit_parsers = [
-  { group = "<!-- 0 -->Breaking", message = "!:" },
-  { group = "<!-- 1 -->Features", message = "^feat" },
-  { group = "<!-- 2 -->Bug Fixes", message = "^fix" },
-  { group = "<!-- 3 -->Performance", message = "^perf" },
-  { group = "<!-- 4 -->Documentation", message = "^doc" },
-  { group = "<!-- 5 -->Refactor", message = "^refactor" },
-  { group = "<!-- 6 -->Testing", message = "^test" },
-  { group = "<!-- 7 -->Build System and CI", message = "^build" },
-  { group = "<!-- 7 -->Build System and CI", message = "^ci" },
-  { group = "<!-- 8 -->Other", message = ".*" },
+  { message = "!:", group = "<!-- 0 -->Breaking" },
+  { message = "^feat", group = "<!-- 1 -->Features" },
+  { message = "^fix", group = "<!-- 2 -->Bug Fixes" },
+  { message = "^perf", group = "<!-- 3 -->Performance" },
+  { message = "^doc", group = "<!-- 4 -->Documentation" },
+  { message = "^refactor", group = "<!-- 5 -->Refactor" },
+  { message = "^test", group = "<!-- 6 -->Testing" },
+  { message = "^build", group = "<!-- 7 -->Build System and CI" },
+  { message = "^ci", group = "<!-- 7 -->Build System and CI" },
+  { message = ".*", group = "<!-- 8 -->Other" },
 ]
 # filter out the commits that are not matched by commit parsers
 filter_commits = false

.github/pull_request_template.md

@@ -1,6 +0,0 @@
-### AI Policy
-
-- [ ] I have read the [AI Policy](https://tree-sitter.github.io/tree-sitter/6-contributing.html#ai-policy) and this PR complies with it.
-- [ ] If AI tools were used: I have disclosed the tool and extent of usage below.
-
-<!-- If you used AI tools, state which tool and how it was used. Delete this section if not applicable. -->

.github/scripts/reviewers_remove.js

@@ -0,0 +1,16 @@
+module.exports = async ({ github, context }) => {
+  const requestedReviewers = await github.rest.pulls.listRequestedReviewers({
+    owner: context.repo.owner,
+    repo: context.repo.repo,
+    pull_number: context.issue.number,
+  });
+
+  const reviewers = requestedReviewers.data.users.map((e) => e.login);
+
+  github.rest.pulls.removeRequestedReviewers({
+    owner: context.repo.owner,
+    repo: context.repo.repo,
+    pull_number: context.issue.number,
+    reviewers: reviewers,
+  });
+};

.github/scripts/wasm_stdlib.js

@@ -1,35 +0,0 @@
-module.exports = async ({ github, context, core }) => {
-  if (context.eventName !== 'pull_request') return;
-
-  const prNumber = context.payload.pull_request.number;
-  const owner = context.repo.owner;
-  const repo = context.repo.repo;
-
-  const files = await github.paginate(github.rest.pulls.listFiles, {
-    owner,
-    repo,
-    pull_number: prNumber,
-    per_page: 100
-  });
-
-  const changedFiles = files.map(file => file.filename);
-
-  const wasmStdLibSources = [
-    'lib/src/wasm-stdlib/external_scanner_allocator.c',
-    'lib/src/wasm-stdlib/imports.txt',
-    'lib/src/wasm-stdlib/libc.c',
-    'lib/src/wasm-stdlib/stdio.c'
-  ];
-  const dirChanged = changedFiles.some(file =>
-    wasmStdLibSources.includes(file) ||
-    file.startsWith('lib/src/wasm-stdlib/libc/ctype/') ||
-    file.startsWith('lib/src/wasm-stdlib/libc/string/')
-  );
-
-  if (!dirChanged) return;
-
-  const wasmStdLibHeader = 'lib/src/wasm-stdlib/external_scanner_stdlib.h';
-  const requiredChanged = changedFiles.includes(wasmStdLibHeader);
-
-  if (!requiredChanged) core.setFailed(`Changes detected in the Wasm stdlib sources but ${wasmStdLibHeader} was not modified.`);
-};

.github/workflows/backport.yml

@@ -14,20 +14,17 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
-        with:
-          persist-credentials: true
-          ref: ${{ github.event.pull_request.base.ref }}
+        uses: actions/checkout@v6
 
       - name: Create app token
-        uses: actions/create-github-app-token@v3
+        uses: actions/create-github-app-token@v2
         id: app-token
         with:
           app-id: ${{ vars.BACKPORT_APP }}
           private-key: ${{ secrets.BACKPORT_KEY }}
 
       - name: Create backport PR
-        uses: korthout/backport-action@v4.6.0
+        uses: korthout/backport-action@v3
         with:
           pull_title: "${pull_title}"
           label_pattern: "^ci:backport ([^ ]+)$"

.github/workflows/bindgen.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
 
       - name: Set up stable Rust toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1

.github/workflows/build.yml

@@ -26,7 +26,6 @@ jobs:
           - windows-x86
           - macos-arm64
           - macos-x64
-          - illumos-x64
           - wasm32
 
         include:
@@ -46,9 +45,6 @@ jobs:
           - { platform: macos-x64       , target: x86_64-apple-darwin           , os: macos-15-intel   }
           - { platform: wasm32          , target: wasm32-unknown-unknown        , os: ubuntu-24.04     }
 
-          # illumos is not supported OOTB, it runs in a vm
-          - { platform: illumos-x64     , target: x86_64-unknown-illumos        , os: ubuntu-24.04     , vm: true , no-run: true }
-
           # Extra features
           - { platform: linux-arm64     , features: wasm }
           - { platform: linux-x64       , features: wasm , run-wasm-test: true }
@@ -73,7 +69,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v7.0.1
+      uses: actions/checkout@v6
 
     - name: Set up cross-compilation
       if: matrix.cross
@@ -95,7 +91,7 @@ jobs:
 
     - name: Cache Emscripten SDK
       if: contains(matrix.features, 'wasm') && (matrix.run-wasm-test || !inputs.run-test)
-      uses: actions/cache@v6
+      uses: actions/cache@v4
       with:
         path: emsdk
         key: emsdk-${{ env.EMSCRIPTEN_VERSION }}-${{ runner.os }}-${{ runner.arch }}
@@ -116,22 +112,17 @@ jobs:
 
     - name: Set up Node.js
       if: contains(matrix.features, 'wasm') && (matrix.run-wasm-test || !inputs.run-test)
-      uses: actions/setup-node@v7.0.0
+      uses: actions/setup-node@v4
       with:
         node-version: 24
         cache: npm
         cache-dependency-path: lib/binding_web/package-lock.json
 
     - name: Set up Rust
-      if: ${{ !matrix.vm }}
       uses: actions-rust-lang/setup-rust-toolchain@v1
       with:
         target: ${{ matrix.target }}
 
-    - name: Install Rust Wasm test target
-      if: matrix.run-wasm-test
-      run: rustup toolchain install nightly --profile minimal --component rust-src
-
     - name: Install cross-compilation toolchain
       if: matrix.cross
       run: |
@@ -201,7 +192,7 @@ jobs:
         WASMTIME_REPO: https://github.com/bytecodealliance/wasmtime
 
     - name: Build C library (make)
-      if: runner.os != 'Windows' && !matrix.vm
+      if: runner.os != 'Windows'
       run: |
         if [[ $PLATFORM == linux-arm ]]; then
           CC=arm-linux-gnueabihf-gcc; AR=arm-linux-gnueabihf-ar
@@ -215,10 +206,10 @@ jobs:
         make -j CFLAGS="$CFLAGS" CC=$CC AR=$AR
       env:
         PLATFORM: ${{ matrix.platform }}
-        CFLAGS: -g -Werror -Wall -Wextra -Wshadow -Wpedantic -Werror=incompatible-pointer-types -Werror=strict-aliasing -Wstrict-aliasing=2
+        CFLAGS: -g -Werror -Wall -Wextra -Wshadow -Wpedantic -Werror=incompatible-pointer-types
 
     - name: Build C library (CMake)
-      if: "!matrix.cross && !matrix.vm"
+      if: "!matrix.cross"
       run: |
         cmake -S . -B build/static \
           -DBUILD_SHARED_LIBS=OFF \
@@ -237,20 +228,6 @@ jobs:
         CC: ${{ contains(matrix.platform, 'linux') && 'clang' || '' }}
         WASM: ${{ contains(matrix.features, 'wasm') && (matrix.run-wasm-test || !inputs.run-test) && 'ON' || 'OFF' }}
 
-    - name: Build C library and Rust crate (illumos gmake)
-      if: matrix.platform == 'illumos-x64'
-      uses: vmactions/omnios-vm@v1.3.6
-      with:
-        release: r151056-build
-        copyback: false
-        prepare: |
-          pkg install -q build-essential || [ $? -eq 4 ]
-          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable --profile minimal
-        run: |
-          . "$HOME/.cargo/env"
-          gmake -j
-          cargo build -p tree-sitter
-
     - name: Build Wasm library
       if: contains(matrix.features, 'wasm') && (matrix.run-wasm-test || !inputs.run-test)
       shell: bash
@@ -269,7 +246,7 @@ jobs:
       run: cargo check --no-default-features --target='${{ matrix.target }}'
 
     - name: Build target
-      if: "!inputs.run-test && !matrix.vm"
+      if: "!inputs.run-test"
       run: cargo build --release --target='${{ matrix.target }}' --features='${{ (matrix.run-wasm-test || !inputs.run-test) && matrix.features || '' }}' $PACKAGE
       env:
         PACKAGE: ${{ matrix.platform == 'wasm32' && '-p tree-sitter' || '' }}
@@ -293,19 +270,15 @@ jobs:
 
     - name: Run main tests
       if: inputs.run-test && !matrix.no-run
-      run: cargo test --workspace --target='${{ matrix.target }}' --features='${{ (matrix.run-wasm-test || !inputs.run-test) && matrix.features || '' }}'
+      run: cargo test --target='${{ matrix.target }}' --features='${{ (matrix.run-wasm-test || !inputs.run-test) && matrix.features || '' }}'
 
     - name: Run Wasm tests
       if: inputs.run-test && !matrix.no-run && contains(matrix.features, 'wasm') && matrix.run-wasm-test
       run: cargo run -p xtask --target='${{ matrix.target }}' -- test-wasm
 
-    - name: Run Rust Wasm web test
-      if: inputs.run-test && !matrix.no-run && contains(matrix.features, 'wasm') && matrix.run-wasm-test
-      run: cargo run -p xtask --target='${{ matrix.target }}' -- test-rust-wasm-web
-
     - name: Upload CLI artifact
       if: "!inputs.run-test && !matrix.no-run"
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v6
       with:
         name: tree-sitter.${{ matrix.platform }}
         path: target/${{ matrix.target }}/release/tree-sitter${{ contains(matrix.target, 'windows') && '.exe' || '' }}
@@ -314,7 +287,7 @@ jobs:
 
     - name: Upload Wasm artifacts
       if: "!inputs.run-test && matrix.platform == 'linux-x64'"
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v6
       with:
         name: tree-sitter.wasm
         path: |

.github/workflows/ci.yml

@@ -1,14 +1,21 @@
 name: CI
 
 on:
-  push:
-    branches:
-      - 'master'
-      - 'release-[0-9]+.[0-9]+'
   pull_request:
-    branches:
-      - 'master'
-      - 'release-[0-9]+.[0-9]+'
+    paths-ignore:
+      - docs/**
+      - "**/README.md"
+      - CONTRIBUTING.md
+      - LICENSE
+      - cli/src/templates
+  push:
+    branches: [master]
+    paths-ignore:
+      - docs/**
+      - "**/README.md"
+      - CONTRIBUTING.md
+      - LICENSE
+      - cli/src/templates
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -19,7 +26,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
 
       - name: Set up stable Rust toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -27,25 +34,13 @@ jobs:
           toolchain: stable
           components: clippy, rustfmt
 
-      - name: Lint Rust files
-        run: make lint
-
-      - name: Install Taplo
-        uses: taiki-e/install-action@v2
-        with:
-          tool: taplo@0.10.0
-
-      - name: Lint TOML files
-        run: make lint-toml
-
-      - name: Lint web files
-        run: make lint-web
+      - name: Lint files
+        run: |
+          make lint
+          make lint-web
 
   sanitize:
     uses: ./.github/workflows/sanitize.yml
 
   build:
     uses: ./.github/workflows/build.yml
-
-  check-wasm-stdlib:
-    uses: ./.github/workflows/wasm_stdlib.yml

.github/workflows/crate_versions.yml

@@ -11,7 +11,7 @@ jobs:
     if: contains(github.event.pull_request.labels.*.name, 'ci:check release') || github.event_name == 'workflow_dispatch'
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
 
       - name: Set up Rust
         uses: actions-rust-lang/setup-rust-toolchain@v1

.github/workflows/docs.yml

@@ -16,29 +16,35 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
+
+      - name: Set up Rust
+        uses: actions-rust-lang/setup-rust-toolchain@v1
 
       - name: Install mdbook
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
           jq_expr='.assets[] | select(.name | contains("x86_64-unknown-linux-gnu")) | .browser_download_url'
-          url=$(gh api repos/rust-lang/mdbook/releases/tags/v0.5.4 --jq "$jq_expr")
+          url=$(gh api repos/rust-lang/mdbook/releases/tags/v0.4.52 --jq "$jq_expr")
           mkdir mdbook
           curl -sSL "$url" | tar -xz -C mdbook
           printf '%s/mdbook\n' "$PWD" >> "$GITHUB_PATH"
 
+      - name: Install mdbook-admonish
+        run: cargo install mdbook-admonish
+
       - name: Build Book
         run: mdbook build docs
 
       - name: Setup Pages
-        uses: actions/configure-pages@v6
+        uses: actions/configure-pages@v5
 
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v5
+        uses: actions/upload-pages-artifact@v4
         with:
           path: docs/book
 
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v5
+        uses: actions/deploy-pages@v4

.github/workflows/nvim_ts.yml

@@ -3,7 +3,6 @@ name: nvim-treesitter parser tests
 on:
   pull_request:
     paths:
-      - 'lib/**'
       - 'crates/cli/**'
       - 'crates/config/**'
       - 'crates/generate/**'
@@ -26,54 +25,34 @@ jobs:
     name: ${{ matrix.os }} - ${{ matrix.type }}
     runs-on: ${{ matrix.os }}
     env:
-      NVIM: ${{ matrix.os == 'windows-latest' && 'nvim.exe' || 'nvim' }}
-      NVIM_TAG: stable
-      NVIM_DIR: neovim
+      NVIM: ${{ matrix.os == 'windows-latest' && 'nvim-win64\\bin\\nvim.exe' || 'nvim' }}
       NVIM_TS_DIR: nvim-treesitter
     steps:
-      - uses: actions/checkout@v7.0.1
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-      - run: cargo build --profile optimize
+      - uses: actions/checkout@v6
 
-      - name: Clone Neovim
-        uses: actions/checkout@v7.0.1
-        with:
-          repository: neovim/neovim
-          ref: ${{ env.NVIM_TAG }}
-          path: ${{ env.NVIM_DIR }}
-
-      - if: runner.os != 'Windows'
-        name: Setup environment (Posix)
-        run: |
-          echo ${{ github.workspace }}/target/optimize >> "$GITHUB_PATH"
-          echo ${{ github.workspace }}/neovim/build/bin >> "$GITHUB_PATH"
-          echo "VIMRUNTIME=${{ github.workspace }}/neovim/runtime" >> "$GITHUB_ENV"
-
-      - if: runner.os == 'Windows'
-        name: Setup environment (why can't you just be normal?!)
-        run: |
-          ${{ env.NVIM_DIR }}/.github/scripts/env.ps1
-          echo ${{ github.workspace }}/target/optimize >> "$env:GITHUB_PATH"
-          echo ${{ github.workspace }}/neovim/build/bin >> "$env:GITHUB_PATH"
-          echo "VIMRUNTIME=${{ github.workspace }}/neovim/runtime" >> "$env:GITHUB_ENV"
-
-      - name: Build Neovim
-        working-directory: ${{ env.NVIM_DIR }}
-        run: |
-          cmake -S cmake.deps -B .deps -G Ninja -D CMAKE_BUILD_TYPE=Release -D TREESITTER_URL=https://github.com/tree-sitter/tree-sitter/archive/${{ github.event.pull_request.head.sha }}.tar.gz -D DEPS_IGNORE_SHA=TRUE
-          cmake --build .deps --config Release
-          cmake -B build -G Ninja -D CMAKE_BUILD_TYPE=Release
-          cmake --build build --config Release
-
-      - name: Clone nvim-treesitter
-        uses: actions/checkout@v7.0.1
+      - uses: actions/checkout@v6
         with:
           repository: nvim-treesitter/nvim-treesitter
           path: ${{ env.NVIM_TS_DIR }}
+          ref: main
+
+      - if: runner.os != 'Windows'
+        run: echo ${{ github.workspace }}/target/release >> $GITHUB_PATH
+
+      - if: runner.os == 'Windows'
+        run: echo ${{ github.workspace }}/target/release >> $env:GITHUB_PATH
+
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+      - run: cargo build --release
+      - uses: ilammy/msvc-dev-cmd@v1
+
+      - name: Install and prepare Neovim
+        run: bash ./scripts/ci-install.sh
+        working-directory: ${{ env.NVIM_TS_DIR }}
 
       - if: matrix.type == 'generate'
         name: Generate and compile parsers
-        run: $NVIM -l ./scripts/install-parsers.lua --generate --max-jobs=10
+        run: $NVIM -l ./scripts/install-parsers.lua --generate --max-jobs=2
         working-directory: ${{ env.NVIM_TS_DIR }}
         shell: bash
 
@@ -84,13 +63,7 @@ jobs:
         shell: bash
 
       - if: "!cancelled()"
-        name: Test parsers
-        run: $NVIM -l ./scripts/check-parsers.lua
-        working-directory: ${{ env.NVIM_TS_DIR }}
-        shell: bash
-
-      - if: "!cancelled()"
-        name: Test queries
+        name: Check query files
         run: $NVIM -l ./scripts/check-queries.lua
         working-directory: ${{ env.NVIM_TS_DIR }}
         shell: bash

.github/workflows/release.yml

@@ -1,14 +1,7 @@
 name: Release
 
 on:
-  schedule:
-    - cron: '5 5 * * *'
   workflow_dispatch:
-    inputs:
-      tag_name:
-        description: 'Tag name for release'
-        required: false
-        default: nightly
   push:
     tags:
       - v[0-9]+.[0-9]+.[0-9]+
@@ -28,22 +21,11 @@ jobs:
       attestations: write
       contents: write
     steps:
-      - if: github.event_name == 'workflow_dispatch'
-        env:
-          TAG_NAME: ${{ github.event.inputs.tag_name }}
-        run: echo "TAG_NAME=${TAG_NAME}" >> $GITHUB_ENV
-
-      - if: github.event_name == 'schedule'
-        run: echo 'TAG_NAME=nightly' >> $GITHUB_ENV
-
-      - if: github.event_name == 'push'
-        run: echo "TAG_NAME=${GITHUB_REF_NAME}" >> $GITHUB_ENV
-
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
 
       - name: Download build artifacts
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v6
         with:
           path: artifacts
 
@@ -62,7 +44,6 @@ jobs:
 
           for platform in $(cd artifacts; ls | sed 's/^tree-sitter\.//'); do
             exe=$(ls artifacts/tree-sitter.$platform/tree-sitter*)
-            chmod +x $exe
             gzip --stdout --name $exe > target/tree-sitter-$platform.gz
             zip -j9 target/tree-sitter-cli-$platform.zip $exe
           done
@@ -70,24 +51,16 @@ jobs:
           ls -l target/
 
       - name: Generate attestations
-        uses: actions/attest-build-provenance@v4
+        uses: actions/attest-build-provenance@v3
         with:
           subject-path: |
             target/tree-sitter-*.gz
             target/tree-sitter-cli-*.zip
             target/web-tree-sitter.tar.gz
 
-      - if: env.TAG_NAME == 'nightly'
-        run: |
-          echo 'PRERELEASE=--prerelease' >> $GITHUB_ENV
-          gh release delete nightly --yes || true
-          git push https://${GITHUB_ACTOR}:${GH_TOKEN}@github.com/${GITHUB_REPOSITORY} :nightly || true
-        env:
-          GH_TOKEN: ${{ github.token }}
-
       - name: Create release
         run: |-
-          gh release create ${{ env.TAG_NAME }} $PRERELEASE \
+          gh release create $GITHUB_REF_NAME \
             target/tree-sitter-*.gz \
             target/tree-sitter-cli-*.zip \
             target/web-tree-sitter.tar.gz
@@ -96,7 +69,6 @@ jobs:
 
   crates_io:
     name: Publish packages to Crates.io
-    if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.tag_name != 'nightly')
     runs-on: ubuntu-latest
     environment: crates
     permissions:
@@ -105,7 +77,7 @@ jobs:
     needs: release
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
 
       - name: Set up Rust
         uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -121,7 +93,6 @@ jobs:
 
   npm:
     name: Publish packages to npmjs.com
-    if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.tag_name != 'nightly')
     runs-on: ubuntu-latest
     environment: npm
     permissions:
@@ -134,10 +105,10 @@ jobs:
         directory: [crates/cli/npm, lib/binding_web]
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
 
       - name: Set up Node
-        uses: actions/setup-node@v7.0.0
+        uses: actions/setup-node@v6
         with:
           node-version: 24
           registry-url: https://registry.npmjs.org

.github/workflows/response.yml

@@ -17,13 +17,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout script
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
         with:
           sparse-checkout: .github/scripts/close_unresponsive.js
           sparse-checkout-cone-mode: false
 
       - name: Run script
-        uses: actions/github-script@v9
+        uses: actions/github-script@v8
         with:
           script: |
             const script = require('./.github/scripts/close_unresponsive.js')
@@ -35,13 +35,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout script
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
         with:
           sparse-checkout: .github/scripts/remove_response_label.js
           sparse-checkout-cone-mode: false
 
       - name: Run script
-        uses: actions/github-script@v9
+        uses: actions/github-script@v8
         with:
           script: |
             const script = require('./.github/scripts/remove_response_label.js')

.github/workflows/reviewers_remove.yml

@@ -11,21 +11,15 @@ jobs:
   remove-reviewers:
     runs-on: ubuntu-latest
     steps:
-      - name: Remove reviewers
-        uses: actions/github-script@v9
+      - name: Checkout script
+        uses: actions/checkout@v6
+        with:
+          sparse-checkout: .github/scripts/reviewers_remove.js
+          sparse-checkout-cone-mode: false
+
+      - name: Run script
+        uses: actions/github-script@v8
         with:
           script: |
-            const requestedReviewers = await github.rest.pulls.listRequestedReviewers({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              pull_number: context.issue.number,
-            });
-
-            const reviewers = requestedReviewers.data.users.map((e) => e.login);
-
-            github.rest.pulls.removeRequestedReviewers({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              pull_number: context.issue.number,
-              reviewers: reviewers,
-            });
+            const script = require('./.github/scripts/reviewers_remove.js')
+            await script({github, context})

.github/workflows/sanitize.yml

@@ -15,7 +15,7 @@ jobs:
       TREE_SITTER: ${{ github.workspace }}/target/release/tree-sitter
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
 
       - name: Install UBSAN library
         run: sudo apt-get update -y && sudo apt-get install -y libubsan1

.github/workflows/spam.yml

@@ -16,13 +16,13 @@ jobs:
     if: github.event.label.name == 'spam'
     steps:
       - name: Checkout script
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
         with:
           sparse-checkout: .github/scripts/close_spam.js
           sparse-checkout-cone-mode: false
 
       - name: Run script
-        uses: actions/github-script@v9
+        uses: actions/github-script@v8
         with:
           script: |
             const script = require('./.github/scripts/close_spam.js')

.github/workflows/wasm_exports.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7.0.1
+        uses: actions/checkout@v6
 
       - name: Set up stable Rust toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -31,7 +31,7 @@ jobs:
       - name: Build C library (make)
         run: make -j CFLAGS="$CFLAGS"
         env:
-          CFLAGS: -g -Werror -Wall -Wextra -Wshadow -Wpedantic -Werror=incompatible-pointer-types -Werror=strict-aliasing -Wstrict-aliasing=2
+          CFLAGS: -g -Werror -Wall -Wextra -Wshadow -Wpedantic -Werror=incompatible-pointer-types
 
       - name: Build Wasm Library
         working-directory: lib/binding_web

.github/workflows/wasm_stdlib.yml

@@ -1,19 +0,0 @@
-name: Check Wasm Stdlib build
-
-on:
-  workflow_call:
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v7.0.1
-
-      - name: Check directory changes
-        uses: actions/github-script@v9
-        with:
-          script: |
-            const scriptPath = `${process.env.GITHUB_WORKSPACE}/.github/scripts/wasm_stdlib.js`;
-            const script = require(scriptPath);
-            return script({ github, context, core });

.taplo.toml

@@ -1,19 +0,0 @@
-[formatting]
-column_width = 100
-compact_arrays = false
-reorder_inline_tables = true
-reorder_keys = true
-
-[[rule]]
-include = [ "**/Cargo.toml" ]
-keys = [ "package" ]
-
-[rule.formatting]
-reorder_keys = false
-
-[[rule]]
-include = [ "**/Cargo.toml" ]
-keys = [ "profile" ]
-
-[rule.formatting]
-reorder_keys = false

.zed/settings.json

@@ -0,0 +1,11 @@
+{
+  "lsp": {
+    "rust-analyzer": {
+      "initialization_options": {
+        "cargo": {
+          "features": "all"
+        }
+      }
+    }
+  }
+}

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.13)
 
 project(tree-sitter
-        VERSION "0.28.0"
+        VERSION "0.26.9"
         DESCRIPTION "An incremental parsing system for programming tools"
         HOMEPAGE_URL "https://tree-sitter.github.io/tree-sitter/"
         LANGUAGES C)
@@ -33,8 +33,7 @@ if(MSVC)
 else()
   target_compile_options(tree-sitter PRIVATE
                          -Wall -Wextra -Wshadow -Wpedantic
-                         -Werror=incompatible-pointer-types
-                         -Werror=strict-aliasing -Wstrict-aliasing=2)
+                         -Werror=incompatible-pointer-types)
 endif()
 
 if(TREE_SITTER_FEATURE_WASM)

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-default-members = [ "crates/cli" ]
+default-members = ["crates/cli"]
 members = [
   "crates/cli",
   "crates/config",
@@ -14,22 +14,25 @@ members = [
 resolver = "2"
 
 [workspace.package]
-authors = [ "Max Brunsfeld <maxbrunsfeld@gmail.com>", "Amaan Qureshi <amaanq12@gmail.com>" ]
-categories = [ "command-line-utilities", "parsing" ]
-edition = "2024"
+version = "0.26.9"
+authors = [
+  "Max Brunsfeld <maxbrunsfeld@gmail.com>",
+  "Amaan Qureshi <amaanq12@gmail.com>",
+]
+edition = "2021"
+rust-version = "1.84"
 homepage = "https://tree-sitter.github.io/tree-sitter"
-keywords = [ "incremental", "parsing" ]
-license = "MIT"
 repository = "https://github.com/tree-sitter/tree-sitter"
-rust-version = "1.90"
-version = "0.28.0"
+license = "MIT"
+keywords = ["incremental", "parsing"]
+categories = ["command-line-utilities", "parsing"]
 
 [workspace.lints.clippy]
-cargo = { level = "warn", priority = -1 }
 dbg_macro = "deny"
-nursery = { level = "warn", priority = -1 }
-pedantic = { level = "warn", priority = -1 }
 todo = "deny"
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+cargo = { level = "warn", priority = -1 }
 
 # The lints below are a specific subset of the pedantic+nursery lints
 # that we explicitly allow in the tree-sitter codebase because they either:
@@ -38,31 +41,52 @@ todo = "deny"
 # 2. Are unnecessary, or
 # 3. Worsen the code
 
+branches_sharing_code = "allow"
+cast_lossless = "allow"
 cast_possible_truncation = "allow"
 cast_possible_wrap = "allow"
 cast_precision_loss = "allow"
 cast_sign_loss = "allow"
+checked_conversions = "allow"
+cognitive_complexity = "allow"
+collection_is_never_read = "allow"
+fallible_impl_from = "allow"
+fn_params_excessive_bools = "allow"
+inline_always = "allow"
 if_not_else = "allow"
 items_after_statements = "allow"
+match_wildcard_for_single_variants = "allow"
 missing_errors_doc = "allow"
 missing_panics_doc = "allow"
+module_name_repetitions = "allow"
 multiple_crate_versions = "allow"
+needless_for_each = "allow"
+obfuscated_if_else = "allow"
 option_if_let_else = "allow"
+or_fun_call = "allow"
+range_plus_one = "allow"
+redundant_clone = "allow"
+redundant_closure_for_method_calls = "allow"
+ref_option = "allow"
 similar_names = "allow"
 string_lit_as_bytes = "allow"
 struct_excessive_bools = "allow"
+struct_field_names = "allow"
+transmute_undefined_repr = "allow"
 too_many_lines = "allow"
-tuple_array_conversions = "allow"
+unnecessary_wraps = "allow"
+unused_self = "allow"
+used_underscore_items = "allow"
 
 [workspace.lints.rust]
 mismatched_lifetime_syntaxes = "allow"
 
 [profile.optimize]
 inherits = "release"
-codegen-units = 1    # Maximum size reduction optimizations.
+strip = true         # Automatically strip symbols from the binary.
 lto = true           # Link-time optimization.
 opt-level = 3        # Optimization level 3.
-strip = true         # Automatically strip symbols from the binary.
+codegen-units = 1    # Maximum size reduction optimizations.
 
 [profile.size]
 inherits = "optimize"
@@ -70,69 +94,70 @@ opt-level = "s"       # Optimize for size.
 
 [profile.release-dev]
 inherits = "release"
-codegen-units = 256
+lto = false
 debug = true
 debug-assertions = true
-incremental = true
-lto = false
 overflow-checks = true
+incremental = true
+codegen-units = 256
 
 [workspace.dependencies]
 ansi_colours = "1.2.3"
-anstyle = "1.0.14"
-anyhow = "1.0.102"
-bstr = "1.12.1"
-cc = "1.2.63"
-clap = { features = [
+anstyle = "1.0.13"
+anyhow = "1.0.100"
+bstr = "1.12.0"
+cc = "1.2.48"
+clap = { version = "4.5.53", features = [
   "cargo",
   "derive",
   "env",
   "help",
   "string",
   "unstable-styles",
-], version = "4.5.58" }
-clap_complete = "4.6.3"
+] }
+clap_complete = "4.5.61"
 clap_complete_nushell = "4.5.10"
 crc32fast = "1.5.0"
-ctor = "0.6.3"
-ctrlc = { features = [ "termination" ], version = "3.5.2" }
-dialoguer = { features = [ "fuzzy-select" ], version = "0.12.0" }
+ctor = "0.2.9"
+ctrlc = { version = "3.5.0", features = ["termination"] }
+dialoguer = { version = "0.11.0", features = ["fuzzy-select"] }
 etcetera = "0.11.0"
+fs4 = "0.12.0"
 glob = "0.3.3"
-hashbrown = { default-features = false, version = "0.17.1" }
 heck = "0.5.0"
 html-escape = "0.2.13"
-indexmap = "2.13.0"
-indoc = "2.0.7"
+indexmap = "2.12.1"
+indoc = "2.0.6"
 libloading = "0.9.0"
-log = { features = [ "std" ], version = "0.4.30" }
-memchr = "2.8.1"
+log = { version = "0.4.28", features = ["std"] }
+memchr = "2.7.6"
 once_cell = "1.21.3"
 pretty_assertions = "1.4.1"
-rand = "0.10.1"
-regex = "1.12.3"
-regex-syntax = "0.8.9"
+rand = "0.8.5"
+regex = "1.11.3"
+regex-syntax = "0.8.6"
 rustc-hash = "2.1.1"
-schemars = "1.2.1"
-semver = { features = [ "serde" ], version = "1.0.27" }
-serde = { features = [ "derive" ], version = "1.0.228" }
-serde_json = { features = [ "preserve_order" ], version = "1.0.150" }
+schemars = "1.0.5"
+semver = { version = "1.0.27", features = ["serde"] }
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = { version = "1.0.145", features = ["preserve_order"] }
 similar = "2.7.0"
+smallbitvec = "2.6.0"
 streaming-iterator = "0.1.9"
-tempfile = "3.25.0"
-thiserror = "2.0.18"
+tempfile = "3.23.0"
+thiserror = "2.0.17"
 tiny_http = "0.12.0"
 topological-sort = "0.2.2"
 unindent = "0.2.4"
 walkdir = "2.5.0"
-wasmparser = "0.244.0"
-webbrowser = "1.2.1"
+wasmparser = "0.243.0"
+webbrowser = "1.0.5"
 
-tree-sitter = { path = "./lib", version = "0.28.0" }
-tree-sitter-config = { path = "./crates/config", version = "0.28.0" }
-tree-sitter-generate = { default-features = false, path = "./crates/generate", version = "0.28.0" }
-tree-sitter-highlight = { path = "./crates/highlight", version = "0.28.0" }
-tree-sitter-loader = { path = "./crates/loader", version = "0.28.0" }
-tree-sitter-tags = { path = "./crates/tags", version = "0.28.0" }
+tree-sitter = { version = "0.26.9", path = "./lib" }
+tree-sitter-generate = { version = "0.26.9", path = "./crates/generate", default-features = false }
+tree-sitter-loader = { version = "0.26.9", path = "./crates/loader" }
+tree-sitter-config = { version = "0.26.9", path = "./crates/config" }
+tree-sitter-highlight = { version = "0.26.9", path = "./crates/highlight" }
+tree-sitter-tags = { version = "0.26.9", path = "./crates/tags" }
 
-tree-sitter-language = { path = "./crates/language", version = "0.1.8" }
+tree-sitter-language = { version = "0.1", path = "./crates/language" }

Dockerfile

@@ -0,0 +1,10 @@
+FROM rust:1.76-buster
+
+WORKDIR /app
+
+RUN apt-get update
+RUN apt-get install -y nodejs
+
+COPY . .
+
+CMD cargo test --all-features

Makefile

@@ -1,4 +1,4 @@
-VERSION := 0.28.0
+VERSION := 0.26.9
 DESCRIPTION := An incremental parsing system for programming tools
 HOMEPAGE_URL := https://tree-sitter.github.io/tree-sitter/
 
@@ -22,7 +22,7 @@ OBJ := $(SRC:.c=.o)
 
 # define default flags, and override to append mandatory flags
 ARFLAGS := rcs
-CFLAGS ?= -O3 -Wall -Wextra -Wshadow -Wpedantic -Werror=incompatible-pointer-types -Werror=strict-aliasing -Wstrict-aliasing=2
+CFLAGS ?= -O3 -Wall -Wextra -Wshadow -Wpedantic -Werror=incompatible-pointer-types
 override CFLAGS += -std=c11 -fPIC -fvisibility=hidden
 override CFLAGS += -D_POSIX_C_SOURCE=200112L -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_DARWIN_C_SOURCE
 override CFLAGS += -Ilib/src -Ilib/src/wasm -Ilib/include
@@ -129,13 +129,8 @@ lint-web:
 	npm --prefix lib/binding_web ci
 	npm --prefix lib/binding_web run lint
 
-lint-toml:
-	taplo check
-	taplo format --check --diff
-
 format:
 	cargo fmt --all
-	taplo format
 
 changelog:
 	@git-cliff --config .github/cliff.toml --prepend CHANGELOG.md --latest --github-token $(shell gh auth token)

Package.swift

@@ -0,0 +1,35 @@
+// swift-tools-version: 5.8
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "TreeSitter",
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "TreeSitter",
+            targets: ["TreeSitter"]),
+    ],
+    targets: [
+        .target(name: "TreeSitter",
+                path: "lib",
+                exclude: [
+                        "src/unicode/ICU_SHA",
+                        "src/unicode/README.md",
+                        "src/unicode/LICENSE",
+                        "src/wasm/stdlib-symbols.txt",
+                        "src/lib.c",
+                ],
+                sources: ["src"],
+                publicHeadersPath: "include",
+                cSettings: [
+                        .headerSearchPath("src"),
+                        .define("_POSIX_C_SOURCE", to: "200112L"),
+                        .define("_DEFAULT_SOURCE"),
+                        .define("_BSD_SOURCE"),
+                        .define("_DARWIN_C_SOURCE"),
+                ]),
+    ],
+    cLanguageStandard: .c11
+)

build.zig

@@ -4,56 +4,51 @@ pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    var threaded: std.Io.Threaded = .init(b.allocator, .{});
-    defer threaded.deinit();
-    const io = threaded.io();
-
     const wasm = b.option(bool, "enable-wasm", "Enable Wasm support") orelse false;
     const shared = b.option(bool, "build-shared", "Build a shared library") orelse false;
     const amalgamated = b.option(bool, "amalgamated", "Build using an amalgamated source") orelse false;
 
-    var tree_sitter = b.createModule(.{
-        .target = target,
-        .optimize = optimize,
-        .link_libc = true,
-        .pic = if (shared) true else null,
-    });
     const lib: *std.Build.Step.Compile = b.addLibrary(.{
         .name = "tree-sitter",
         .linkage = if (shared) .dynamic else .static,
-        .root_module = tree_sitter,
+        .root_module = b.createModule(.{
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+            .pic = if (shared) true else null,
+        }),
     });
 
     if (amalgamated) {
-        tree_sitter.addCSourceFile(.{
+        lib.addCSourceFile(.{
             .file = b.path("lib/src/lib.c"),
             .flags = &.{"-std=c11"},
         });
     } else {
-        const files = try findSourceFiles(b, io);
+        const files = try findSourceFiles(b);
         defer b.allocator.free(files);
-        tree_sitter.addCSourceFiles(.{
+        lib.addCSourceFiles(.{
             .root = b.path("lib/src"),
             .files = files,
             .flags = &.{"-std=c11"},
         });
     }
 
-    tree_sitter.addIncludePath(b.path("lib/include"));
-    tree_sitter.addIncludePath(b.path("lib/src"));
-    tree_sitter.addIncludePath(b.path("lib/src/wasm"));
+    lib.addIncludePath(b.path("lib/include"));
+    lib.addIncludePath(b.path("lib/src"));
+    lib.addIncludePath(b.path("lib/src/wasm"));
 
-    tree_sitter.addCMacro("_POSIX_C_SOURCE", "200112L");
-    tree_sitter.addCMacro("_DEFAULT_SOURCE", "");
-    tree_sitter.addCMacro("_BSD_SOURCE", "");
-    tree_sitter.addCMacro("_DARWIN_C_SOURCE", "");
+    lib.root_module.addCMacro("_POSIX_C_SOURCE", "200112L");
+    lib.root_module.addCMacro("_DEFAULT_SOURCE", "");
+    lib.root_module.addCMacro("_BSD_SOURCE", "");
+    lib.root_module.addCMacro("_DARWIN_C_SOURCE", "");
 
     if (wasm) {
         if (b.lazyDependency(wasmtimeDep(target.result), .{})) |wasmtime| {
-            tree_sitter.addCMacro("TREE_SITTER_FEATURE_WASM", "");
-            tree_sitter.addSystemIncludePath(wasmtime.path("include"));
-            tree_sitter.addLibraryPath(wasmtime.path("lib"));
-            if (shared) tree_sitter.linkSystemLibrary("wasmtime", .{});
+            lib.root_module.addCMacro("TREE_SITTER_FEATURE_WASM", "");
+            lib.addSystemIncludePath(wasmtime.path("include"));
+            lib.addLibraryPath(wasmtime.path("lib"));
+            if (shared) lib.linkSystemLibrary("wasmtime");
         }
     }
 
@@ -127,14 +122,14 @@ pub fn wasmtimeDep(target: std.Target) []const u8 {
     );
 }
 
-fn findSourceFiles(b: *std.Build, io: std.Io) ![]const []const u8 {
+fn findSourceFiles(b: *std.Build) ![]const []const u8 {
     var sources: std.ArrayListUnmanaged([]const u8) = .empty;
 
-    var dir = try b.build_root.handle.openDir(io, "lib/src", .{ .iterate = true });
+    var dir = try b.build_root.handle.openDir("lib/src", .{ .iterate = true });
     var iter = dir.iterate();
-    defer dir.close(io);
+    defer dir.close();
 
-    while (try iter.next(io)) |entry| {
+    while (try iter.next()) |entry| {
         if (entry.kind != .file) continue;
         const file = entry.name;
         const ext = std.fs.path.extension(file);

build.zig.zon

@@ -1,8 +1,8 @@
 .{
     .name = .tree_sitter,
     .fingerprint = 0x841224b447ac0d4f,
-    .version = "0.28.0",
-    .minimum_zig_version = "0.16.0",
+    .version = "0.26.9",
+    .minimum_zig_version = "0.14.1",
     .paths = .{
         "build.zig",
         "build.zig.zon",
@@ -13,83 +13,83 @@
     },
     .dependencies = .{
         .wasmtime_c_api_aarch64_android = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-aarch64-android-c-api.tar.xz",
-            .hash = "N-V-__8AAIp_mQVzQOITXcYcWxYLJkvB1W1SvLlrdiU2G7fj",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-aarch64-android-c-api.tar.xz",
+            .hash = "N-V-__8AALMiGASd47LSknbKQql17HO2FheOwXir1xlaLYGi",
             .lazy = true,
         },
         .wasmtime_c_api_aarch64_linux = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-aarch64-linux-c-api.tar.xz",
-            .hash = "N-V-__8AAMztsgU5Aj4oI3MRHXJVe5rW72op-kT_78I3kZVM",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-aarch64-linux-c-api.tar.xz",
+            .hash = "N-V-__8AAN8SGQQM1HMPgco0FcHMrtbfoL9l4d8uD7u3-H3w",
             .lazy = true,
         },
         .wasmtime_c_api_aarch64_macos = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-aarch64-macos-c-api.tar.xz",
-            .hash = "N-V-__8AANZxOwT27sdrKxDDGGKsiwtcZlHy204xAWNIgDBH",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-aarch64-macos-c-api.tar.xz",
+            .hash = "N-V-__8AAMvm3QILhOKJLq6J4uOxz2fS86MvrZy3e20QRdhv",
             .lazy = true,
         },
         .wasmtime_c_api_aarch64_musl = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-aarch64-musl-c-api.tar.xz",
-            .hash = "N-V-__8AAJL1zQW9yxC98uc60lSuVUHhH77QHTto0zwIQnBj",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-aarch64-musl-c-api.tar.xz",
+            .hash = "N-V-__8AANe5FwRutrlGR5KSf60j5drXkjtdYjOIFVcMwcsd",
             .lazy = true,
         },
         .wasmtime_c_api_aarch64_windows = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-aarch64-windows-c-api.zip",
-            .hash = "N-V-__8AAHRCtQU93hJcRFOgVcof3IQpRV9stT2Pp54wpJc2",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-aarch64-windows-c-api.zip",
+            .hash = "N-V-__8AAO8engSk8mbtpni7b76ypOmfIsCK6htGYMhsR_nA",
             .lazy = true,
         },
         .wasmtime_c_api_armv7_linux = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-armv7-linux-c-api.tar.xz",
-            .hash = "N-V-__8AAJaW6gT8QdULOU0jxX4a_DOCA5YD6cxWBC8IqhQF",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-armv7-linux-c-api.tar.xz",
+            .hash = "N-V-__8AAEd9agPSwkFBEojA24WL1Unf0KOMuqoUqG-pRRir",
             .lazy = true,
         },
         .wasmtime_c_api_i686_linux = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-i686-linux-c-api.tar.xz",
-            .hash = "N-V-__8AANguMgVX4XMhdOVkdj4yfFKXrG8RTgZDs3nQB8J8",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-i686-linux-c-api.tar.xz",
+            .hash = "N-V-__8AAAnCpgNLSkpLTZ6RfMDnur8g_i_etj4RPmS5pLxu",
             .lazy = true,
         },
         .wasmtime_c_api_i686_windows = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-i686-windows-c-api.zip",
-            .hash = "N-V-__8AANY9ggXg4rK2_1o3EIlrCq124l5RfykPv-DPforq",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-i686-windows-c-api.zip",
+            .hash = "N-V-__8AAGkVhgSgju7L1cM3FdPQlRx5Dr29vibseC2XIcRD",
             .lazy = true,
         },
         .wasmtime_c_api_riscv64gc_linux = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-riscv64gc-linux-c-api.tar.xz",
-            .hash = "N-V-__8AAPDtCAdQ0dD9Rs-qWl-kPr2c7L3PVsUVjwy12Iz1",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-riscv64gc-linux-c-api.tar.xz",
+            .hash = "N-V-__8AANWsUgXjmNb6b6MPqiIIpxkB2pHlpsK9WFE_pMro",
             .lazy = true,
         },
         .wasmtime_c_api_s390x_linux = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-s390x-linux-c-api.tar.xz",
-            .hash = "N-V-__8AANA3BwY1ZOoGCWCR_tTY9G1vfIX128RGVxufN3ov",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-s390x-linux-c-api.tar.xz",
+            .hash = "N-V-__8AALHyUwRWbDeltYLrh2OUyT_9NTTuVczOm-jQfe6-",
             .lazy = true,
         },
         .wasmtime_c_api_x86_64_android = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-x86_64-android-c-api.tar.xz",
-            .hash = "N-V-__8AAF4AIgY0ltjevj1ybGfvMU1ErPRnNve5X1TmvCru",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-x86_64-android-c-api.tar.xz",
+            .hash = "N-V-__8AAAcCmgT9G-DxL0qxfcxL_eW6eaPNpj5TLzbpA79G",
             .lazy = true,
         },
         .wasmtime_c_api_x86_64_linux = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-x86_64-linux-c-api.tar.xz",
-            .hash = "N-V-__8AAIR0cAbjf3DkrTbu81Oq_zociz-0lCpb5DR0lIC9",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-x86_64-linux-c-api.tar.xz",
+            .hash = "N-V-__8AAP0LmQQI5JNYDZWZZpfBPNQPcTSLDKVb7nf7RpW7",
             .lazy = true,
         },
         .wasmtime_c_api_x86_64_macos = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-x86_64-macos-c-api.tar.xz",
-            .hash = "N-V-__8AAFJ4lgRgCBnYdz8-Yfc4hLve45Hv-0RICAEuCp4s",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-x86_64-macos-c-api.tar.xz",
+            .hash = "N-V-__8AAMuMVANLZp9NajHfONmzD5wpAak_HoJ-D4u_lepy",
             .lazy = true,
         },
         .wasmtime_c_api_x86_64_mingw = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-x86_64-mingw-c-api.zip",
-            .hash = "N-V-__8AAMxZxQZUpp1cU8J5zgLiMNq4e4dy0hcchlQFy03J",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-x86_64-mingw-c-api.zip",
+            .hash = "N-V-__8AAHwQ-QS8romH2p8Up6Qrb7cVRlXSfI0ydmczere1",
             .lazy = true,
         },
         .wasmtime_c_api_x86_64_musl = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-x86_64-musl-c-api.tar.xz",
-            .hash = "N-V-__8AAN5pWgZrZBt8VYWkN82WjyFe3DkGcE7uLn3jpt38",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-x86_64-musl-c-api.tar.xz",
+            .hash = "N-V-__8AABUtnAQZcXhlBhK-kS3ZD7knKR8kyS9kGmt8yrU-",
             .lazy = true,
         },
         .wasmtime_c_api_x86_64_windows = .{
-            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v48.0.1/wasmtime-v48.0.1-x86_64-windows-c-api.zip",
-            .hash = "N-V-__8AAEIJkgaVHFETgakbognNUpFELuV17vpjw6NjsWhQ",
+            .url = "https://github.com/bytecodealliance/wasmtime/releases/download/v36.0.9/wasmtime-v36.0.9-x86_64-windows-c-api.zip",
+            .hash = "N-V-__8AAPHVXQUTiXOnJXE7bCVUYKSU_rrixTIQys-cVlSj",
             .lazy = true,
         },
     },

crates/cli/Cargo.toml

@@ -5,13 +5,14 @@ description = "CLI tool for developing, testing, and using Tree-sitter parsers"
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
+readme = "README.md"
 homepage.workspace = true
 repository.workspace = true
 documentation = "https://docs.rs/tree-sitter-cli"
 license.workspace = true
 keywords.workspace = true
 categories.workspace = true
-include = [ "build.rs", "README.md", "LICENSE", "benches/*", "src/**" ]
+include = ["build.rs", "README.md", "LICENSE", "benches/*", "src/**"]
 
 [lints]
 workspace = true
@@ -20,18 +21,18 @@ workspace = true
 path = "src/tree_sitter_cli.rs"
 
 [[bin]]
-doc = false
 name = "tree-sitter"
 path = "src/main.rs"
+doc = false
 
 [[bench]]
-harness = false
 name = "benchmark"
+harness = false
 
 [features]
-default = [ "qjs-rt" ]
-qjs-rt = [ "tree-sitter-generate/qjs-rt" ]
-wasm = [ "tree-sitter/wasm", "tree-sitter-loader/wasm" ]
+default = ["qjs-rt"]
+wasm = ["tree-sitter/wasm", "tree-sitter-loader/wasm"]
+qjs-rt = ["tree-sitter-generate/qjs-rt"]
 
 [dependencies]
 ansi_colours.workspace = true
@@ -66,19 +67,19 @@ wasmparser.workspace = true
 webbrowser.workspace = true
 
 tree-sitter.workspace = true
+tree-sitter-generate = { workspace = true, features = ["load"] }
 tree-sitter-config.workspace = true
-tree-sitter-generate = { features = [ "load" ], workspace = true }
 tree-sitter-highlight.workspace = true
 tree-sitter-loader.workspace = true
 tree-sitter-tags.workspace = true
 
 [dev-dependencies]
 encoding_rs = "0.8.35"
-tree_sitter_proc_macro = { package = "tree-sitter-tests-proc-macro", path = "src/tests/proc_macro" }
 widestring = "1.2.1"
+tree_sitter_proc_macro = { path = "src/tests/proc_macro", package = "tree-sitter-tests-proc-macro" }
 
-pretty_assertions.workspace = true
 tempfile.workspace = true
+pretty_assertions.workspace = true
 unindent.workspace = true
 
 [package.metadata.binstall]

crates/cli/README.md

@@ -7,12 +7,11 @@
 [npmjs.com]: https://www.npmjs.org/package/tree-sitter-cli
 [npmjs.com badge]: https://img.shields.io/npm/v/tree-sitter-cli.svg?color=%23BF4A4A
 
-The Tree-sitter CLI allows you to develop, test, and use Tree-sitter grammars from the command line. It works on `MacOS`,
-`Linux`, and `Windows`.
+The Tree-sitter CLI allows you to develop, test, and use Tree-sitter grammars from the command line. It works on `MacOS`, `Linux`, and `Windows`.
 
 ### Installation
 
-You can install the `tree-sitter-cli` with [`cargo-binstall`](https://github.com/cargo-bins/cargo-binstall):
+You can install the `tree-sitter-cli` with `cargo-binstall`:
 
 ```sh
 cargo binstall tree-sitter-cli
@@ -34,11 +33,9 @@ The `tree-sitter` binary itself has no dependencies, but specific commands have
 
 ### Commands
 
-* `generate` - The `tree-sitter generate` command will generate a Tree-sitter parser based on the grammar in the current
-  working directory. See [the documentation] for more information.
+* `generate` - The `tree-sitter generate` command will generate a Tree-sitter parser based on the grammar in the current working directory. See [the documentation] for more information.
 
-* `test` - The `tree-sitter test` command will run the unit tests for the Tree-sitter parser in the current working directory.
-  See [the documentation] for more information.
+* `test` - The `tree-sitter test` command will run the unit tests for the Tree-sitter parser in the current working directory. See [the documentation] for more information.
 
 * `parse` - The `tree-sitter parse` command will parse a file (or list of files) using Tree-sitter parsers.
 

crates/cli/benches/benchmark.rs

@@ -2,6 +2,7 @@ use std::{
     collections::BTreeMap,
     env, fs,
     path::{Path, PathBuf},
+    str,
     sync::LazyLock,
     time::Instant,
 };
@@ -9,8 +10,6 @@ use std::{
 use anyhow::Context;
 use log::info;
 use tree_sitter::{Language, Parser, Query};
-#[cfg(feature = "wasm")]
-use tree_sitter::{WasmStore, wasmtime};
 use tree_sitter_loader::{CompileConfig, Loader};
 
 include!("../src/tests/helpers/dirs.rs");
@@ -22,16 +21,10 @@ static EXAMPLE_FILTER: LazyLock<Option<String>> =
 static REPETITION_COUNT: LazyLock<usize> = LazyLock::new(|| {
     env::var("TREE_SITTER_BENCHMARK_REPETITION_COUNT").map_or(5, |s| s.parse::<usize>().unwrap())
 });
-static WASM: LazyLock<bool> = LazyLock::new(|| env::var_os("TREE_SITTER_BENCHMARK_WASM").is_some());
 static TEST_LOADER: LazyLock<Loader> =
     LazyLock::new(|| Loader::with_parser_lib_path(SCRATCH_DIR.clone()));
-#[cfg(feature = "wasm")]
-static WASM_ENGINE: LazyLock<wasmtime::Engine> = LazyLock::new(Default::default);
 
-#[expect(
-    clippy::type_complexity,
-    reason = "complex map type reflects benchmark data structure"
-)]
+#[allow(clippy::type_complexity)]
 static EXAMPLE_AND_QUERY_PATHS_BY_LANGUAGE_DIR: LazyLock<
     BTreeMap<PathBuf, (Vec<PathBuf>, Vec<PathBuf>)>,
 > = LazyLock::new(|| {
@@ -43,14 +36,22 @@ static EXAMPLE_AND_QUERY_PATHS_BY_LANGUAGE_DIR: LazyLock<
             if let Ok(example_files) = fs::read_dir(dir.join("examples")) {
                 example_paths.extend(example_files.filter_map(|p| {
                     let p = p.unwrap().path();
-                    if p.is_file() { Some(p) } else { None }
+                    if p.is_file() {
+                        Some(p)
+                    } else {
+                        None
+                    }
                 }));
             }
 
             if let Ok(query_files) = fs::read_dir(dir.join("queries")) {
                 query_paths.extend(query_files.filter_map(|p| {
                     let p = p.unwrap().path();
-                    if p.is_file() { Some(p) } else { None }
+                    if p.is_file() {
+                        Some(p)
+                    } else {
+                        None
+                    }
                 }));
             }
         } else {
@@ -92,26 +93,22 @@ fn main() {
     {
         let language_name = language_path.file_name().unwrap().to_str().unwrap();
 
-        if let Some(filter) = LANGUAGE_FILTER.as_ref()
-            && language_name != filter.as_str()
-        {
-            continue;
+        if let Some(filter) = LANGUAGE_FILTER.as_ref() {
+            if language_name != filter.as_str() {
+                continue;
+            }
         }
 
         info!("\nLanguage: {language_name}");
-        let language = if *WASM {
-            get_wasm_language(language_name, &mut parser)
-        } else {
-            get_language(language_path)
-        };
+        let language = get_language(language_path);
         parser.set_language(&language).unwrap();
 
         info!("  Constructing Queries");
         for path in query_paths {
-            if let Some(filter) = EXAMPLE_FILTER.as_ref()
-                && !path.to_str().unwrap().contains(filter.as_str())
-            {
-                continue;
+            if let Some(filter) = EXAMPLE_FILTER.as_ref() {
+                if !path.to_str().unwrap().contains(filter.as_str()) {
+                    continue;
+                }
             }
 
             parse(path, max_path_length, |source| {
@@ -124,10 +121,10 @@ fn main() {
         info!("  Parsing Valid Code:");
         let mut normal_speeds = Vec::new();
         for example_path in example_paths {
-            if let Some(filter) = EXAMPLE_FILTER.as_ref()
-                && !example_path.to_str().unwrap().contains(filter.as_str())
-            {
-                continue;
+            if let Some(filter) = EXAMPLE_FILTER.as_ref() {
+                if !example_path.to_str().unwrap().contains(filter.as_str()) {
+                    continue;
+                }
             }
 
             normal_speeds.push(parse(example_path, max_path_length, |code| {
@@ -142,10 +139,10 @@ fn main() {
         {
             if other_language_path != language_path {
                 for example_path in example_paths {
-                    if let Some(filter) = EXAMPLE_FILTER.as_ref()
-                        && !example_path.to_str().unwrap().contains(filter.as_str())
-                    {
-                        continue;
+                    if let Some(filter) = EXAMPLE_FILTER.as_ref() {
+                        if !example_path.to_str().unwrap().contains(filter.as_str()) {
+                            continue;
+                        }
                     }
 
                     error_speeds.push(parse(example_path, max_path_length, |code| {
@@ -223,32 +220,3 @@ fn get_language(path: &Path) -> Language {
         .with_context(|| format!("Failed to load language at path {}", src_path.display()))
         .unwrap()
 }
-
-#[cfg(feature = "wasm")]
-fn get_wasm_language(language_name: &str, parser: &mut Parser) -> Language {
-    let wasm_language_name = language_name.replace('-', "_");
-    let wasm_path = ROOT_DIR
-        .join("target")
-        .join("release")
-        .join(format!("tree-sitter-{language_name}.wasm"));
-    let wasm = fs::read(&wasm_path)
-        .with_context(|| {
-            format!(
-                "Failed to read {}. Generate Wasm fixtures with `cargo xtask generate-fixtures --wasm`",
-                wasm_path.display()
-            )
-        })
-        .unwrap();
-    let mut store = WasmStore::new(&WASM_ENGINE).expect("Failed to create Wasm store");
-    let language = store
-        .load_language(&wasm_language_name, &wasm)
-        .with_context(|| format!("Failed to load Wasm language at {}", wasm_path.display()))
-        .unwrap();
-    parser.set_wasm_store(store).unwrap();
-    language
-}
-
-#[cfg(not(feature = "wasm"))]
-fn get_wasm_language(_language_name: &str, _parser: &mut Parser) -> Language {
-    panic!("Wasm benchmarking requires the `wasm` feature");
-}

crates/cli/eslint/package.json

@@ -17,7 +17,7 @@
     "tree-sitter"
   ],
   "dependencies": {
-    "eslint-plugin-jsdoc": "^62.7.0"
+    "eslint-plugin-jsdoc": "^50.2.4"
   },
   "peerDependencies": {
     "eslint": ">= 9"

crates/cli/npm/dsl.d.ts

@@ -3,22 +3,18 @@ type BlankRule = { type: 'BLANK' };
 type ChoiceRule = { type: 'CHOICE'; members: Rule[] };
 type FieldRule = { type: 'FIELD'; name: string; content: Rule };
 type ImmediateTokenRule = { type: 'IMMEDIATE_TOKEN'; content: Rule };
-type PatternRule = { type: 'PATTERN'; value: string; flags?: string };
-type PrecedenceValue = string | number;
+type PatternRule = { type: 'PATTERN'; value: string };
 type PrecDynamicRule = { type: 'PREC_DYNAMIC'; content: Rule; value: number };
-type PrecLeftRule = { type: 'PREC_LEFT'; content: Rule; value: PrecedenceValue };
-type PrecRightRule = { type: 'PREC_RIGHT'; content: Rule; value: PrecedenceValue };
-type PrecRule = { type: 'PREC'; content: Rule; value: PrecedenceValue };
+type PrecLeftRule = { type: 'PREC_LEFT'; content: Rule; value: number };
+type PrecRightRule = { type: 'PREC_RIGHT'; content: Rule; value: number };
+type PrecRule = { type: 'PREC'; content: Rule; value: number };
 type Repeat1Rule = { type: 'REPEAT1'; content: Rule };
 type RepeatRule = { type: 'REPEAT'; content: Rule };
 type ReservedRule = { type: 'RESERVED'; content: Rule; context_name: string };
 type SeqRule = { type: 'SEQ'; members: Rule[] };
 type StringRule = { type: 'STRING'; value: string };
 type SymbolRule<Name extends string> = { type: 'SYMBOL'; name: Name };
-type PrecedenceEntry = StringRule | SymbolRule<string>;
 type TokenRule = { type: 'TOKEN'; content: Rule };
-type EOFRule = { type: 'EOF' };
-
 
 type Rule =
   | AliasRule
@@ -37,8 +33,7 @@ type Rule =
   | SeqRule
   | StringRule
   | SymbolRule<string>
-  | TokenRule
-  | EOFRule;
+  | TokenRule;
 
 declare class RustRegex {
   value: string;
@@ -91,8 +86,8 @@ interface Grammar<
    */
   precedences?: (
     $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
-    previous: PrecedenceEntry[][],
-  ) => (string | PrecedenceEntry)[][],
+    previous: Rule[][],
+  ) => RuleOrLiteral[][],
 
   /**
    * An array of arrays of rule names. Each inner array represents a set of
@@ -106,8 +101,8 @@ interface Grammar<
    */
   conflicts?: (
     $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
-    previous: SymbolRule<string>[][],
-  ) => SymbolRule<string>[][];
+    previous: Rule[][],
+  ) => RuleOrLiteral[][];
 
   /**
    * An array of token names which can be returned by an _external scanner_.
@@ -132,11 +127,9 @@ interface Grammar<
    * specify extras: `$ => []` in your grammar.
    *
    *  @param $ grammar rules
-   *  @param previous array of extras from the base grammar
    */
   extras?: (
     $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
-    previous: Rule[],
   ) => RuleOrLiteral[];
 
   /**
@@ -149,8 +142,8 @@ interface Grammar<
    */
   inline?: (
     $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
-    previous: SymbolRule<string>[],
-  ) => SymbolRule<string>[];
+    previous: Rule[],
+  ) => RuleOrLiteral[];
 
   /**
    * A list of hidden rule names that should be considered supertypes in the
@@ -162,8 +155,8 @@ interface Grammar<
    */
   supertypes?: (
     $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
-    previous: SymbolRule<string>[],
-  ) => SymbolRule<string>[];
+    previous: Rule[],
+  ) => RuleOrLiteral[];
 
   /**
    * The name of a token that will match keywords for the purpose of the
@@ -173,47 +166,24 @@ interface Grammar<
    *
    * @see https://tree-sitter.github.io/tree-sitter/creating-parsers/3-writing-the-grammar#keyword-extraction
    */
-  word?: (
-    $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
-  ) => SymbolRule<string>;
+  word?: ($: GrammarSymbols<RuleName | BaseGrammarRuleName>) => RuleOrLiteral;
 
 
   /**
    * Mapping of names to reserved word sets. The first reserved word set is the
    * global word set, meaning it applies to every rule in every parse state.
-   * The other word sets can be used with the `reserved` function. Each callback
-   * receives the base grammar's reserved word set of the same name as its second
-   * argument, or `undefined` if no matching set exists.
+   * The other word sets can be used with the `reserved` function.
    */
   reserved?: Record<
     string,
-    (
-      $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
-      previous: Rule[] | undefined,
-    ) => RuleOrLiteral[]
+    ($: GrammarSymbols<RuleName | BaseGrammarRuleName>) => RuleOrLiteral[]
   >;
 }
 
-/**
- * Return type of grammar(). The runtime evaluates and normalizes the grammar
- * beneath a "grammar" key. Optional input fields become required output fields
- * with default values when not provided.
- */
 type GrammarSchema<RuleName extends string> = {
-  grammar: {
-    name: string;
-    /** Base grammar name when extending; undefined for root grammars. */
-    inherits: string | undefined;
-    rules: Record<RuleName, Rule>;
-    precedences: PrecedenceEntry[][];
-    conflicts: string[][];
-    externals: Rule[];
-    extras: Rule[];
-    inline: string[];
-    supertypes: string[];
-    word: string | undefined;
-    reserved: Record<string, Rule[]>;
-  };
+  [K in keyof Grammar<RuleName>]: K extends 'rules'
+  ? Record<RuleName, Rule>
+  : Grammar<RuleName>[K];
 };
 
 /**
@@ -341,7 +311,7 @@ declare const prec: {
    *
    * @see https://www.gnu.org/software/bison/manual/html_node/Generalized-LR-Parsing.html
    */
-  dynamic(value: number, rule: RuleOrLiteral): PrecDynamicRule;
+  dynamic(value: string | number, rule: RuleOrLiteral): PrecDynamicRule;
 };
 
 /**
@@ -412,19 +382,6 @@ declare const token: {
   immediate(rule: RuleOrLiteral): ImmediateTokenRule;
 };
 
-/**
- * Matches the end of input. May only appear as the final symbol of a
- * (possibly nested) sequence; a production ending in `eof()` reduces only
- * when the lookahead is end-of-input, rather than shifting a token.
- *
- * Choice branches that continue past `eof()` are dropped as unreachable,
- * and `eof()` is not allowed inside `token()`.
- *
- * Useful when a rule should match either an explicit terminator (e.g. a
- * newline) or the end of the file.
- */
-declare function eof(): EOFRule;
-
 /**
  * Creates a new language grammar with the provided schema.
  *

crates/cli/npm/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "tree-sitter-cli",
-  "version": "0.28.0",
+  "version": "0.26.9",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "tree-sitter-cli",
-      "version": "0.28.0",
+      "version": "0.26.9",
       "hasInstallScript": true,
       "license": "MIT",
       "bin": {

crates/cli/npm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-cli",
-  "version": "0.28.0",
+  "version": "0.26.9",
   "author": {
     "name": "Max Brunsfeld",
     "email": "maxbrunsfeld@gmail.com"

crates/cli/package.nix

@@ -13,7 +13,7 @@
   installShellFiles,
 }:
 let
-  canRunHost = stdenv.buildPlatform.canExecute stdenv.hostPlatform;
+  isCross = stdenv.targetPlatform == stdenv.buildPlatform;
 in
 rustPlatform.buildRustPackage {
   pname = "tree-sitter-cli";
@@ -28,7 +28,7 @@ rustPlatform.buildRustPackage {
     pkg-config
     nodejs_22
   ]
-  ++ lib.optionals canRunHost [ installShellFiles ];
+  ++ lib.optionals (!isCross) [ installShellFiles ];
 
   cargoLock.lockFile = ../../Cargo.lock;
 
@@ -42,9 +42,9 @@ rustPlatform.buildRustPackage {
   '';
 
   preCheck = "export HOME=$TMPDIR";
-  doCheck = canRunHost;
+  doCheck = !isCross;
 
-  postInstall = lib.optionalString canRunHost ''
+  postInstall = lib.optionalString (!isCross) ''
     installShellCompletion --cmd tree-sitter \
       --bash <($out/bin/tree-sitter complete --shell bash) \
       --zsh  <($out/bin/tree-sitter complete --shell zsh) \

crates/cli/src/fuzz.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use log::{error, info};
-use rand::RngExt;
+use rand::Rng;
 use regex::Regex;
 use tree_sitter::{Language, Parser};
 
@@ -25,7 +25,7 @@ use crate::{
         random::Rand,
     },
     parse::perform_edit,
-    test::{DiffKey, TestDiff, TestEntry, TestExpectation, parse_tests, render_test_output},
+    test::{parse_tests, strip_sexp_fields, DiffKey, TestDiff, TestEntry},
 };
 
 pub static LOG_ENABLED: LazyLock<bool> = LazyLock::new(|| env::var("TREE_SITTER_LOG").is_ok());
@@ -63,9 +63,9 @@ fn regex_env_var(name: &'static str) -> Option<Regex> {
 #[must_use]
 pub fn new_seed() -> usize {
     int_env_var("TREE_SITTER_SEED").unwrap_or_else(|| {
-        let mut rng = rand::rng();
-        let seed = rng.random_range(0..=usize::MAX);
-        eprintln!("fuzz seed: {seed}");
+        let mut rng = rand::thread_rng();
+        let seed = rng.gen::<usize>();
+        info!("Seed: {seed}");
         seed
     })
 }
@@ -97,7 +97,9 @@ pub fn fuzz_language_corpus(
                         .iter()
                         .any(|lang| lang.as_ref() == language_name)
             }
-            TestEntry::Group { children, .. } => {
+            TestEntry::Group {
+                ref mut children, ..
+            } => {
                 children.retain_mut(|child| retain(child, language_name));
                 !children.is_empty()
             }
@@ -109,16 +111,12 @@ pub fn fuzz_language_corpus(
     let corpus_dir = grammar_dir.join(subdir).join("test").join("corpus");
 
     if !corpus_dir.exists() || !corpus_dir.is_dir() {
-        error!(
-            "No corpus directory found, ensure that you have a `test/corpus` directory in your grammar directory with at least one test file."
-        );
+        error!("No corpus directory found, ensure that you have a `test/corpus` directory in your grammar directory with at least one test file.");
         return;
     }
 
     if std::fs::read_dir(&corpus_dir).unwrap().count() == 0 {
-        error!(
-            "No corpus files found in `test/corpus`, ensure that you have at least one test file in your corpus directory."
-        );
+        error!("No corpus files found in `test/corpus`, ensure that you have at least one test file in your corpus directory.");
         return;
     }
 
@@ -144,7 +142,7 @@ pub fn fuzz_language_corpus(
         .take()
         .unwrap_or_default()
         .into_iter()
-        .chain(tests.iter().filter(|t| t.skip()).map(get_test_name))
+        .chain(tests.iter().filter(|x| x.skip).map(get_test_name))
         .map(|x| (x, 0))
         .collect::<HashMap<String, usize>>();
 
@@ -169,8 +167,31 @@ pub fn fuzz_language_corpus(
         println!("  {test_index}. {test_name}");
 
         let passed = allocations::record_checked(|| {
-            let check_output = !test.error();
-            test.check_initial_parse(language, &test_name, check_output)
+            let mut log_session = None;
+            let mut parser = get_parser(&mut log_session, "log.html");
+            parser.set_language(language).unwrap();
+            set_included_ranges(&mut parser, &test.input, test.template_delimiters);
+
+            let tree = parser.parse(&test.input, None).unwrap();
+
+            if test.error {
+                return true;
+            }
+
+            let mut actual_output = tree.root_node().to_sexp();
+            if !test.has_fields {
+                actual_output = strip_sexp_fields(&actual_output);
+            }
+
+            if actual_output != test.output {
+                println!("Incorrect initial parse for {test_name}");
+                DiffKey::print();
+                println!("{}", TestDiff::new(&actual_output, &test.output));
+                println!();
+                return false;
+            }
+
+            true
         })
         .unwrap_or_else(|e| {
             error!("{e}");
@@ -250,9 +271,12 @@ pub fn fuzz_language_corpus(
                 let tree3 = parser.parse(&input, Some(&tree2)).unwrap();
 
                 // Verify that the final tree matches the expectation from the corpus.
-                let actual_output = render_test_output(&input, &tree3, test.cst, test.has_fields).unwrap();
+                let mut actual_output = tree3.root_node().to_sexp();
+                if !test.has_fields {
+                    actual_output = strip_sexp_fields(&actual_output);
+                }
 
-                if actual_output != test.output && !test.error() {
+                if actual_output != test.output && !test.error {
                     println!("Incorrect parse for {test_name} - seed {seed}");
                     DiffKey::print();
                     println!("{}", TestDiff::new(&actual_output, &test.output));
@@ -300,56 +324,12 @@ pub struct FlattenedTest {
     pub input: Vec<u8>,
     pub output: String,
     pub languages: Vec<Box<str>>,
-    pub expectation: TestExpectation,
+    pub error: bool,
+    pub skip: bool,
     pub has_fields: bool,
-    pub cst: bool,
     pub template_delimiters: Option<(&'static str, &'static str)>,
 }
 
-impl FlattenedTest {
-    #[must_use]
-    fn skip(&self) -> bool {
-        self.expectation == TestExpectation::Skip
-    }
-
-    #[must_use]
-    fn error(&self) -> bool {
-        self.expectation == TestExpectation::Error
-    }
-
-    #[must_use]
-    pub(crate) fn check_initial_parse(
-        &self,
-        language: &Language,
-        display_name: &str,
-        check_output: bool,
-    ) -> bool {
-        let mut log_session = None;
-        let mut parser = get_parser(&mut log_session, "log.html");
-        parser.set_language(language).unwrap();
-        set_included_ranges(&mut parser, &self.input, self.template_delimiters);
-
-        let tree = parser.parse(&self.input, None).unwrap();
-
-        if !check_output {
-            return true;
-        }
-
-        let actual_output =
-            render_test_output(&self.input, &tree, self.cst, self.has_fields).unwrap();
-
-        if actual_output == self.output {
-            true
-        } else {
-            println!("Incorrect initial parse for {display_name}");
-            DiffKey::print();
-            println!("{}", TestDiff::new(&actual_output, &self.output));
-            println!();
-            false
-        }
-    }
-}
-
 #[must_use]
 pub fn flatten_tests(
     test: TestEntry,
@@ -382,20 +362,20 @@ pub fn flatten_tests(
                     if !include.is_match(&name) {
                         return;
                     }
-                } else if let Some(exclude) = exclude
-                    && exclude.is_match(&name)
-                {
-                    return;
+                } else if let Some(exclude) = exclude {
+                    if exclude.is_match(&name) {
+                        return;
+                    }
                 }
 
                 result.push(FlattenedTest {
                     name,
                     input,
                     output,
-                    languages: attributes.languages,
-                    expectation: attributes.expectation,
                     has_fields,
-                    cst: attributes.cst,
+                    languages: attributes.languages,
+                    error: attributes.error,
+                    skip: attributes.skip,
                     template_delimiters: None,
                 });
             }

crates/cli/src/fuzz/allocations.rs

@@ -2,21 +2,19 @@ use std::{
     collections::HashMap,
     os::raw::c_void,
     sync::{
-        Mutex,
         atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
+        Mutex,
     },
 };
 
 #[ctor::ctor]
 unsafe fn initialize_allocation_recording() {
-    unsafe {
-        tree_sitter::set_allocator(Some(tree_sitter::Allocator {
-            malloc: ts_record_malloc,
-            calloc: ts_record_calloc,
-            realloc: ts_record_realloc,
-            free: ts_record_free,
-        }));
-    }
+    tree_sitter::set_allocator(
+        Some(ts_record_malloc),
+        Some(ts_record_calloc),
+        Some(ts_record_realloc),
+        Some(ts_record_free),
+    );
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -35,7 +33,7 @@ thread_local! {
     static RECORDER: AllocationRecorder = AllocationRecorder::default();
 }
 
-unsafe extern "C" {
+extern "C" {
     fn malloc(size: usize) -> *mut c_void;
     fn calloc(count: usize, size: usize) -> *mut c_void;
     fn realloc(ptr: *mut c_void, size: usize) -> *mut c_void;
@@ -105,11 +103,9 @@ fn record_dealloc(ptr: *mut c_void) {
 /// freed by calling `ts_record_free`.
 #[must_use]
 pub unsafe extern "C" fn ts_record_malloc(size: usize) -> *mut c_void {
-    unsafe {
-        let result = malloc(size);
-        record_alloc(result);
-        result
-    }
+    let result = malloc(size);
+    record_alloc(result);
+    result
 }
 
 /// # Safety
@@ -118,11 +114,9 @@ pub unsafe extern "C" fn ts_record_malloc(size: usize) -> *mut c_void {
 /// freed by calling `ts_record_free`.
 #[must_use]
 pub unsafe extern "C" fn ts_record_calloc(count: usize, size: usize) -> *mut c_void {
-    unsafe {
-        let result = calloc(count, size);
-        record_alloc(result);
-        result
-    }
+    let result = calloc(count, size);
+    record_alloc(result);
+    result
 }
 
 /// # Safety
@@ -131,16 +125,14 @@ pub unsafe extern "C" fn ts_record_calloc(count: usize, size: usize) -> *mut c_v
 /// freed by calling `ts_record_free`.
 #[must_use]
 pub unsafe extern "C" fn ts_record_realloc(ptr: *mut c_void, size: usize) -> *mut c_void {
-    unsafe {
-        let result = realloc(ptr, size);
-        if ptr.is_null() {
-            record_alloc(result);
-        } else if !core::ptr::eq(ptr, result) {
-            record_dealloc(ptr);
-            record_alloc(result);
-        }
-        result
+    let result = realloc(ptr, size);
+    if ptr.is_null() {
+        record_alloc(result);
+    } else if !core::ptr::eq(ptr, result) {
+        record_dealloc(ptr);
+        record_alloc(result);
     }
+    result
 }
 
 /// # Safety
@@ -148,8 +140,6 @@ pub unsafe extern "C" fn ts_record_realloc(ptr: *mut c_void, size: usize) -> *mu
 /// The caller must ensure that `ptr` was allocated by a previous call
 /// to `ts_record_malloc`, `ts_record_calloc`, or `ts_record_realloc`.
 pub unsafe extern "C" fn ts_record_free(ptr: *mut c_void) {
-    unsafe {
-        record_dealloc(ptr);
-        free(ptr);
-    }
+    record_dealloc(ptr);
+    free(ptr);
 }

crates/cli/src/fuzz/corpus_test.rs

@@ -1,22 +1,10 @@
 use tree_sitter::{LogType, Node, Parser, Point, Range, Tree};
 
-use super::{LOG_ENABLED, LOG_GRAPH_ENABLED, scope_sequence::ScopeSequence};
+use super::{scope_sequence::ScopeSequence, LOG_ENABLED, LOG_GRAPH_ENABLED};
 use crate::util;
 
-struct SizeCheckFrame<'a> {
-    node: Node<'a>,
-    end_byte: usize,
-    end_point: Point,
-    child_count: u32,
-    child_index: u32,
-    last_child_end_byte: usize,
-    last_child_end_point: Point,
-    some_child_has_changes: bool,
-    actual_named_child_count: usize,
-}
-
-impl SizeCheckFrame<'_> {
-    fn new<'a>(node: Node<'a>, line_offsets: &[usize]) -> SizeCheckFrame<'a> {
+pub fn check_consistent_sizes(tree: &Tree, input: &[u8]) {
+    fn check(node: Node, line_offsets: &[usize]) {
         let start_byte = node.start_byte();
         let end_byte = node.end_byte();
         let start_point = node.start_position();
@@ -30,21 +18,37 @@ impl SizeCheckFrame<'_> {
         );
         assert_eq!(end_byte, line_offsets[end_point.row] + end_point.column);
 
-        SizeCheckFrame {
-            node,
-            end_byte,
-            end_point,
-            child_count: node.child_count(),
-            child_index: 0,
-            last_child_end_byte: start_byte,
-            last_child_end_point: start_point,
-            some_child_has_changes: false,
-            actual_named_child_count: 0,
+        let mut last_child_end_byte = start_byte;
+        let mut last_child_end_point = start_point;
+        let mut some_child_has_changes = false;
+        let mut actual_named_child_count = 0;
+        for i in 0..node.child_count() {
+            let child = node.child(i as u32).unwrap();
+            assert!(child.start_byte() >= last_child_end_byte);
+            assert!(child.start_position() >= last_child_end_point);
+            check(child, line_offsets);
+            if child.has_changes() {
+                some_child_has_changes = true;
+            }
+            if child.is_named() {
+                actual_named_child_count += 1;
+            }
+            last_child_end_byte = child.end_byte();
+            last_child_end_point = child.end_position();
+        }
+
+        assert_eq!(actual_named_child_count, node.named_child_count());
+
+        if node.child_count() > 0 {
+            assert!(end_byte >= last_child_end_byte);
+            assert!(end_point >= last_child_end_point);
+        }
+
+        if some_child_has_changes {
+            assert!(node.has_changes());
         }
     }
-}
 
-pub fn check_consistent_sizes(tree: &Tree, input: &[u8]) {
     let mut line_offsets = vec![0];
     for (i, c) in input.iter().enumerate() {
         if *c == b'\n' {
@@ -52,41 +56,7 @@ pub fn check_consistent_sizes(tree: &Tree, input: &[u8]) {
         }
     }
 
-    let mut stack: Vec<SizeCheckFrame> = vec![SizeCheckFrame::new(tree.root_node(), &line_offsets)];
-    while let Some(top) = stack.last_mut() {
-        if top.child_index < top.child_count {
-            let i = top.child_index;
-            let child = top.node.child(i).unwrap();
-
-            assert!(child.start_byte() >= top.last_child_end_byte);
-            assert!(child.start_position() >= top.last_child_end_point);
-            if child.has_changes() {
-                top.some_child_has_changes = true;
-            }
-            if child.is_named() {
-                top.actual_named_child_count += 1;
-            }
-            top.last_child_end_byte = child.end_byte();
-            top.last_child_end_point = child.end_position();
-            top.child_index += 1;
-
-            stack.push(SizeCheckFrame::new(child, &line_offsets));
-            continue;
-        }
-
-        let frame = stack.pop().unwrap();
-        assert_eq!(
-            frame.actual_named_child_count,
-            frame.node.named_child_count()
-        );
-        if frame.child_count > 0 {
-            assert!(frame.end_byte >= frame.last_child_end_byte);
-            assert!(frame.end_point >= frame.last_child_end_point);
-        }
-        if frame.some_child_has_changes {
-            assert!(frame.node.has_changes());
-        }
-    }
+    check(tree.root_node(), &line_offsets);
 }
 
 pub fn check_changed_ranges(old_tree: &Tree, new_tree: &Tree, input: &[u8]) -> Result<(), String> {

crates/cli/src/fuzz/random.rs

@@ -1,4 +1,7 @@
-use rand::{RngExt, SeedableRng, distr::Alphanumeric, rngs::StdRng};
+use rand::{
+    distributions::Alphanumeric,
+    prelude::{Rng, SeedableRng, StdRng},
+};
 
 const OPERATORS: &[char] = &[
     '+', '-', '<', '>', '(', ')', '*', '/', '&', '|', '!', ',', '.', '%',
@@ -13,7 +16,7 @@ impl Rand {
     }
 
     pub fn unsigned(&mut self, max: usize) -> usize {
-        self.0.random_range(0..=max)
+        self.0.gen_range(0..=max)
     }
 
     pub fn words(&mut self, max_count: usize) -> Vec<u8> {

crates/cli/src/fuzz/scope_sequence.rs

@@ -1,13 +1,13 @@
 use tree_sitter::{Point, Range, Tree};
 
 #[derive(Debug)]
-pub struct ScopeSequence<'a>(Vec<ScopeStack<'a>>);
+pub struct ScopeSequence(Vec<ScopeStack>);
 
-type ScopeStack<'a> = Vec<&'a str>;
+type ScopeStack = Vec<&'static str>;
 
-impl<'a> ScopeSequence<'a> {
+impl ScopeSequence {
     #[must_use]
-    pub fn new(tree: &'a Tree) -> Self {
+    pub fn new(tree: &Tree) -> Self {
         let mut result = Self(Vec::new());
         let mut scope_stack = Vec::new();
 
@@ -49,7 +49,7 @@ impl<'a> ScopeSequence<'a> {
         for i in 0..(self.0.len().max(other.0.len())) {
             let stack = &self.0.get(i);
             let other_stack = &other.0.get(i);
-            if *stack != *other_stack && !b"\r\n".contains(&text[i]) {
+            if *stack != *other_stack && ![b'\r', b'\n'].contains(&text[i]) {
                 let containing_range = known_changed_ranges
                     .iter()
                     .find(|range| range.start_point <= position && position < range.end_point);

crates/cli/src/highlight.rs

@@ -4,18 +4,17 @@ use std::{
     fs,
     io::{self, Write as _},
     path::{self, Path, PathBuf},
-    sync::{Arc, atomic::AtomicUsize},
+    str,
+    sync::{atomic::AtomicUsize, Arc},
     time::Instant,
 };
 
 use ansi_colours::{ansi256_from_rgb, rgb_from_ansi256};
 use anstyle::{Ansi256Color, AnsiColor, Color, Effects, RgbColor};
 use anyhow::Result;
-use clap::ValueEnum;
 use log::{info, warn};
-use serde::{Deserialize, Deserializer, Serialize, Serializer, ser::SerializeMap};
-use serde_json::{Value, json};
-use tree_sitter::ffi::{self, TSInputEncoding};
+use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
+use serde_json::{json, Value};
 use tree_sitter_highlight::{HighlightConfiguration, HighlightEvent, Highlighter, HtmlRenderer};
 use tree_sitter_loader::Loader;
 
@@ -26,9 +25,8 @@ pub const HTML_HEAD_HEADER: &str = "
   <style>
     body {
       font-family: monospace
-    }";
-
-pub const HTML_LINE_NUMBER_STYLE: &str = "    .line-number {
+    }
+    .line-number {
       user-select: none;
       text-align: right;
       color: rgba(27,31,35,.3);
@@ -36,7 +34,8 @@ pub const HTML_LINE_NUMBER_STYLE: &str = "    .line-number {
     }
     .line {
       white-space: pre;
-    }";
+    }
+  </style>";
 
 pub const HTML_BODY_HEADER: &str = "
 </head>
@@ -216,11 +215,11 @@ fn parse_style(style: &mut Style, json: Value) {
         style.css = None;
     }
 
-    if let Some(Color::Rgb(RgbColor(red, green, blue))) = style.ansi.get_fg_color()
-        && !terminal_supports_truecolor()
-    {
-        let ansi256 = Color::Ansi256(Ansi256Color(ansi256_from_rgb((red, green, blue))));
-        style.ansi = style.ansi.fg_color(Some(ansi256));
+    if let Some(Color::Rgb(RgbColor(red, green, blue))) = style.ansi.get_fg_color() {
+        if !terminal_supports_truecolor() {
+            let ansi256 = Color::Ansi256(Ansi256Color(ansi256_from_rgb((red, green, blue))));
+            style.ansi = style.ansi.fg_color(Some(ansi256));
+        }
     }
 }
 
@@ -308,40 +307,15 @@ fn terminal_supports_truecolor() -> bool {
         .is_ok_and(|truecolor| truecolor == "truecolor" || truecolor == "24bit")
 }
 
-/// The kind of HTML emitted when highlighting to HTML.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
-pub enum HtmlOutput {
-    /// A complete, self-contained document wrapping a plain
-    /// `<div class="highlight"><pre><code>` block.
-    Document,
-    /// A complete document with a line-number column (a `<table>` layout).
-    #[value(name = "line-numbers")]
-    NumberedDocument,
-    /// Only the code markup, without the surrounding document.
-    Fragment,
-}
-
-/// How token colors are applied in HTML output.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
-pub enum HtmlStyling {
-    /// `class="..."` spans plus a generated `<style>` carrying the theme's colors.
-    Classes,
-    /// `style="..."` spans with the colors inlined.
-    Inline,
-    /// `class="..."` spans with no colors emitted (supply your own stylesheet).
-    Minimal,
-}
-
 pub struct HighlightOptions {
     pub theme: Theme,
     pub check: bool,
     pub captures_path: Option<PathBuf>,
-    /// `None` for regular output, `Some((layout, style))` when emitting HTML.
-    pub html: Option<(HtmlOutput, HtmlStyling)>,
+    pub inline_styles: bool,
+    pub html: bool,
     pub quiet: bool,
     pub print_time: bool,
     pub cancellation_flag: Arc<AtomicUsize>,
-    pub encoding: Option<TSInputEncoding>,
 }
 
 pub fn highlight(
@@ -384,60 +358,29 @@ pub fn highlight(
     }
 
     let source = fs::read(path)?;
-
-    fn is_utf16_le_bom(bom_bytes: &[u8]) -> bool {
-        bom_bytes == [0xFF, 0xFE]
-    }
-
-    fn is_utf16_be_bom(bom_bytes: &[u8]) -> bool {
-        bom_bytes == [0xFE, 0xFF]
-    }
-
-    let encoding = match opts.encoding {
-        None if source.len() >= 2 => {
-            if is_utf16_le_bom(&source[0..2]) {
-                Some(ffi::TSInputEncodingUTF16LE)
-            } else if is_utf16_be_bom(&source[0..2]) {
-                Some(ffi::TSInputEncodingUTF16BE)
-            } else {
-                None
-            }
-        }
-        _ => opts.encoding,
-    };
-
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
     let time = Instant::now();
     let mut highlighter = Highlighter::new();
-    let events = highlighter.highlight(
-        config,
-        &source,
-        encoding,
-        Some(&opts.cancellation_flag),
-        |string| loader.highlight_config_for_injection_string(string),
-    )?;
+    let events =
+        highlighter.highlight(config, &source, Some(&opts.cancellation_flag), |string| {
+            loader.highlight_config_for_injection_string(string)
+        })?;
     let theme = &opts.theme;
 
-    // A fragment is pure code markup, so it must not be prefixed with the filename.
-    let html_fragment = opts
-        .html
-        .is_some_and(|(layout, _)| layout == HtmlOutput::Fragment);
-    if !opts.quiet && print_name && !html_fragment {
+    if !opts.quiet && print_name {
         writeln!(&mut stdout, "{name}")?;
     }
 
-    if let Some((layout, style)) = opts.html {
-        if !opts.quiet && layout != HtmlOutput::Fragment {
+    if opts.html {
+        if !opts.quiet {
             writeln!(&mut stdout, "{HTML_HEAD_HEADER}")?;
-            if layout == HtmlOutput::NumberedDocument {
-                writeln!(&mut stdout, "{HTML_LINE_NUMBER_STYLE}")?;
-            }
-            if style == HtmlStyling::Classes {
-                for (name, style) in theme.highlight_names.iter().zip(&theme.styles) {
-                    if let Some(css) = &style.css {
-                        writeln!(&mut stdout, "    .{name} {{ {css}; }}")?;
-                    }
+            writeln!(&mut stdout, "  <style>")?;
+            let names = theme.highlight_names.iter();
+            let styles = theme.styles.iter();
+            for (name, style) in names.zip(styles) {
+                if let Some(css) = &style.css {
+                    writeln!(&mut stdout, "    .{name} {{ {css}; }}")?;
                 }
             }
             writeln!(&mut stdout, "  </style>")?;
@@ -446,7 +389,7 @@ pub fn highlight(
 
         let mut renderer = HtmlRenderer::new();
         renderer.render(events, &source, &move |highlight, output| {
-            if style == HtmlStyling::Inline {
+            if opts.inline_styles {
                 output.extend(b"style='");
                 output.extend(
                     theme.styles[highlight.0]
@@ -454,6 +397,7 @@ pub fn highlight(
                         .as_ref()
                         .map_or_else(|| "".as_bytes(), |css_style| css_style.as_bytes()),
                 );
+                output.extend(b"'");
             } else {
                 output.extend(b"class='");
                 let mut parts = theme.highlight_names[highlight.0].split('.').peekable();
@@ -463,34 +407,21 @@ pub fn highlight(
                         output.extend(b" ");
                     }
                 }
+                output.extend(b"'");
             }
-            output.extend(b"'");
         })?;
 
         if !opts.quiet {
-            if layout == HtmlOutput::NumberedDocument {
-                writeln!(&mut stdout, "<table>")?;
-                for (i, line) in renderer.lines().enumerate() {
-                    writeln!(
-                        &mut stdout,
-                        "<tr><td class=line-number>{}</td><td class=line>{line}</td></tr>",
-                        i + 1,
-                    )?;
-                }
-                writeln!(&mut stdout, "</table>")?;
-            } else {
-                let mut body = renderer.lines().collect::<String>();
-                if body.ends_with('\n') {
-                    body.pop();
-                }
+            writeln!(&mut stdout, "<table>")?;
+            for (i, line) in renderer.lines().enumerate() {
                 writeln!(
                     &mut stdout,
-                    "<div class=\"highlight\">\n<pre><code>{body}</code></pre>\n</div>",
+                    "<tr><td class=line-number>{}</td><td class=line>{line}</td></tr>",
+                    i + 1,
                 )?;
             }
-            if layout != HtmlOutput::Fragment {
-                writeln!(&mut stdout, "{HTML_FOOTER}")?;
-            }
+            writeln!(&mut stdout, "</table>")?;
+            writeln!(&mut stdout, "{HTML_FOOTER}")?;
         }
     } else {
         let mut style_stack = vec![theme.default_style().ansi];
@@ -537,7 +468,7 @@ mod tests {
         assert_eq!(style.css, None);
 
         // darkcyan is an ANSI color and is preserved
-        unsafe { env::set_var("COLORTERM", "") };
+        env::set_var("COLORTERM", "");
         parse_style(&mut style, Value::String(DARK_CYAN.to_string()));
         assert_eq!(
             style.ansi.get_fg_color(),
@@ -546,7 +477,7 @@ mod tests {
         assert_eq!(style.css, Some("color: #00af87".to_string()));
 
         // junglegreen is not an ANSI color and is preserved when the terminal supports it
-        unsafe { env::set_var("COLORTERM", "truecolor") };
+        env::set_var("COLORTERM", "truecolor");
         parse_style(&mut style, Value::String(JUNGLE_GREEN.to_string()));
         assert_eq!(
             style.ansi.get_fg_color(),
@@ -555,7 +486,7 @@ mod tests {
         assert_eq!(style.css, Some("color: #26a69a".to_string()));
 
         // junglegreen gets approximated as cadetblue when the terminal does not support it
-        unsafe { env::set_var("COLORTERM", "") };
+        env::set_var("COLORTERM", "");
         parse_style(&mut style, Value::String(JUNGLE_GREEN.to_string()));
         assert_eq!(
             style.ansi.get_fg_color(),
@@ -564,9 +495,9 @@ mod tests {
         assert_eq!(style.css, Some("color: #26a69a".to_string()));
 
         if let Ok(environment_variable) = original_environment_variable {
-            unsafe { env::set_var("COLORTERM", environment_variable) };
+            env::set_var("COLORTERM", environment_variable);
         } else {
-            unsafe { env::remove_var("COLORTERM") };
+            env::remove_var("COLORTERM");
         }
     }
 }

crates/cli/src/input.rs

@@ -3,16 +3,15 @@ use std::{
     io::{Read, Write},
     path::{Path, PathBuf},
     sync::{
-        Arc,
         atomic::{AtomicUsize, Ordering},
-        mpsc,
+        mpsc, Arc,
     },
 };
 
-use anyhow::{Context, Result, anyhow, bail};
+use anyhow::{anyhow, bail, Context, Result};
 use glob::glob;
 
-use crate::test::{TestEntry, parse_tests};
+use crate::test::{parse_tests, TestEntry};
 
 pub enum CliInput {
     Paths(Vec<PathBuf>),
@@ -147,6 +146,7 @@ pub fn get_input(
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub fn get_test_info(
     test_entry: &TestEntry,
     target_test: u32,

crates/cli/src/logger.rs

@@ -1,8 +1,12 @@
 use std::io::Write;
 
+use anstyle::{AnsiColor, Color, Style};
 use log::{Level, LevelFilter, Log, Metadata, Record};
 
-use crate::paint::{Paint, RED, YELLOW};
+pub fn paint(color: Option<impl Into<Color>>, text: &str) -> String {
+    let style = Style::new().fg_color(color.map(Into::into));
+    format!("{style}{text}{style:#}")
+}
 
 struct Logger;
 
@@ -13,8 +17,16 @@ impl Log for Logger {
 
     fn log(&self, record: &Record) {
         match record.level() {
-            Level::Error => eprintln!("{} {}", Paint(RED, "Error:"), record.args()),
-            Level::Warn => eprintln!("{} {}", Paint(YELLOW, "Warning:"), record.args()),
+            Level::Error => eprintln!(
+                "{} {}",
+                paint(Some(AnsiColor::Red), "Error:"),
+                record.args()
+            ),
+            Level::Warn => eprintln!(
+                "{} {}",
+                paint(Some(AnsiColor::Yellow), "Warning:"),
+                record.args()
+            ),
             Level::Info | Level::Debug => eprintln!("{}", record.args()),
             Level::Trace => eprintln!(
                 "[{}] {}",

crates/cli/src/main.rs

@@ -5,24 +5,24 @@ use std::{
 };
 
 use anstyle::{AnsiColor, Color, Style};
-use anyhow::{Context, Result, anyhow};
-use clap::{ArgGroup, Args, Command, FromArgMatches as _, Subcommand, ValueEnum, crate_authors};
+use anyhow::{anyhow, Context, Result};
+use clap::{crate_authors, Args, Command, FromArgMatches as _, Subcommand, ValueEnum};
 use clap_complete::generate;
-use dialoguer::{Confirm, FuzzySelect, Input, MultiSelect, theme::ColorfulTheme};
+use dialoguer::{theme::ColorfulTheme, Confirm, FuzzySelect, Input, MultiSelect};
 use heck::ToUpperCamelCase;
 use log::{error, info, warn};
 use regex::Regex;
 use semver::Version as SemverVersion;
-use tree_sitter::{Parser, Point, ffi};
+use tree_sitter::{ffi, Parser, Point};
 use tree_sitter_cli::{
     fuzz::{
-        DEFAULT_EDIT_COUNT, DEFAULT_ITERATION_COUNT, EDIT_COUNT, FuzzOptions, ITERATION_COUNT,
-        LOG_ENABLED, LOG_GRAPH_ENABLED, START_SEED, fuzz_language_corpus,
+        fuzz_language_corpus, FuzzOptions, DEFAULT_EDIT_COUNT, DEFAULT_ITERATION_COUNT, EDIT_COUNT,
+        ITERATION_COUNT, LOG_ENABLED, LOG_GRAPH_ENABLED, START_SEED,
     },
-    highlight::{self, HighlightOptions, HtmlOutput, HtmlStyling},
-    init::{JsonConfigOpts, TREE_SITTER_JSON_SCHEMA, generate_grammar_files},
-    input::{CliInput, get_input, get_tmp_source_file},
-    logger, paint,
+    highlight::{self, HighlightOptions},
+    init::{generate_grammar_files, JsonConfigOpts, TREE_SITTER_JSON_SCHEMA},
+    input::{get_input, get_tmp_source_file, CliInput},
+    logger,
     parse::{self, ParseDebugType, ParseFileOptions, ParseOutput, ParseTheme},
     playground,
     query::{self, QueryFileOptions},
@@ -33,7 +33,7 @@ use tree_sitter_cli::{
     wasm,
 };
 use tree_sitter_config::Config;
-use tree_sitter_generate::{Diagnostic, GenerateError, OptLevel};
+use tree_sitter_generate::OptLevel;
 use tree_sitter_highlight::Highlighter;
 use tree_sitter_loader::{self as loader, Bindings, TreeSitterJSON};
 use tree_sitter_tags::TagsContext;
@@ -188,14 +188,10 @@ struct Build {
     /// Compile a parser in debug mode
     #[arg(long, short = '0')]
     pub debug: bool,
-    /// Display verbose build information
-    #[arg(short, long)]
-    pub verbose: bool,
 }
 
 #[derive(Args)]
 #[command(alias = "p")]
-#[command(group(ArgGroup::new("graph_output").multiple(true)))]
 struct Parse {
     /// The path to a file with paths to source file(s)
     #[arg(long = "paths")]
@@ -211,29 +207,26 @@ struct Parse {
     pub lib_path: Option<PathBuf>,
     /// If `--lib-path` is used, the name of the language used to extract the
     /// library's language function
-    #[arg(long, requires = "lib_path")]
+    #[arg(long)]
     pub lang_name: Option<String>,
     /// Select a language by the scope instead of a file extension
     #[arg(long)]
     pub scope: Option<String>,
     /// Show parsing debug log
     #[arg(long, short = 'd')] // TODO: Rework once clap adds `default_missing_value_t`
-    #[expect(
-        clippy::option_option,
-        reason = "required by clap for optional flag with optional value"
-    )]
+    #[allow(clippy::option_option)]
     pub debug: Option<Option<ParseDebugType>>,
     /// Compile a parser in debug mode
     #[arg(long, short = '0')]
     pub debug_build: bool,
     /// Produce the log.html file with debug graphs
-    #[arg(long, short = 'D', group = "graph_output")]
+    #[arg(long, short = 'D')]
     pub debug_graph: bool,
     /// Compile parsers to Wasm instead of native dynamic libraries
     #[arg(long, hide = cfg!(not(feature = "wasm")))]
     pub wasm: bool,
     /// Output the parse data with graphviz dot
-    #[arg(long = "dot", group = "graph_output")]
+    #[arg(long = "dot")]
     pub output_dot: bool,
     /// Output the parse data in XML format
     #[arg(long = "xml", short = 'x')]
@@ -253,10 +246,7 @@ struct Parse {
     /// Suppress main output
     #[arg(long, short)]
     pub quiet: bool,
-    #[expect(
-        clippy::doc_markdown,
-        reason = "doc string contains format syntax, not code identifiers"
-    )]
+    #[allow(clippy::doc_markdown)]
     /// Apply edits in the format: \"row,col|position delcount insert_text\", can be supplied
     /// multiple times
     #[arg(
@@ -267,8 +257,8 @@ struct Parse {
     /// The encoding of the input files
     #[arg(long)]
     pub encoding: Option<Encoding>,
-    /// Open `log.html` in the default browser, if `--debug-graph` or `--dot` is supplied
-    #[arg(long, requires = "graph_output")]
+    /// Open `log.html` in the default browser, if `--debug-graph` is supplied
+    #[arg(long)]
     pub open_log: bool,
     /// Deprecated: use --json-summary
     #[arg(long, conflicts_with = "json_summary", conflicts_with = "stat")]
@@ -293,9 +283,9 @@ struct Parse {
 
 #[derive(ValueEnum, Clone)]
 pub enum Encoding {
-    Utf8 = 0,
-    Utf16LE = 1,
-    Utf16BE = 2,
+    Utf8,
+    Utf16LE,
+    Utf16BE,
 }
 
 #[derive(Args)]
@@ -318,7 +308,7 @@ struct Test {
     pub lib_path: Option<PathBuf>,
     /// If `--lib-path` is used, the name of the language used to extract the
     /// library's language function
-    #[arg(long, requires = "lib_path")]
+    #[arg(long)]
     pub lang_name: Option<String>,
     /// Update all syntax trees in corpus files with current parser output
     #[arg(long, short)]
@@ -336,7 +326,7 @@ struct Test {
     #[arg(long, hide = cfg!(not(feature = "wasm")))]
     pub wasm: bool,
     /// Open `log.html` in the default browser, if `--debug-graph` is supplied
-    #[arg(long, requires = "debug_graph")]
+    #[arg(long)]
     pub open_log: bool,
     /// The path to an alternative config.json file
     #[arg(long)]
@@ -344,9 +334,6 @@ struct Test {
     /// Force showing fields in test diffs
     #[arg(long)]
     pub show_fields: bool,
-    /// Force showing '+' and '-' in test diffs
-    #[arg(long)]
-    pub show_diff_markers: bool,
     /// Show parsing statistics
     #[arg(long)]
     pub stat: Option<TestStats>,
@@ -363,10 +350,6 @@ struct Test {
 
 #[derive(Args)]
 #[command(alias = "publish")]
-#[expect(
-    clippy::struct_field_names,
-    reason = "field names map to CLI arguments"
-)]
 /// Display or increment the version of a grammar
 struct Version {
     /// The version to bump to
@@ -406,7 +389,7 @@ struct Fuzz {
     pub lib_path: Option<PathBuf>,
     /// If `--lib-path` is used, the name of the language used to extract the
     /// library's language function
-    #[arg(long, requires = "lib_path")]
+    #[arg(long)]
     pub lang_name: Option<String>,
     #[arg(
         long,
@@ -437,10 +420,6 @@ struct Fuzz {
 
 #[derive(Args)]
 #[command(alias = "q")]
-#[expect(
-    clippy::struct_field_names,
-    reason = "field names map to CLI arguments"
-)]
 struct Query {
     /// Path to a file with queries
     #[arg(index = 1, required = true)]
@@ -453,7 +432,7 @@ struct Query {
     pub lib_path: Option<PathBuf>,
     /// If `--lib-path` is used, the name of the language used to extract the
     /// library's language function
-    #[arg(long, requires = "lib_path")]
+    #[arg(long)]
     pub lang_name: Option<String>,
     /// Measure execution time
     #[arg(long, short)]
@@ -508,20 +487,14 @@ struct Highlight {
     /// Generate highlighting as an HTML document
     #[arg(long, short = 'H')]
     pub html: bool,
-    /// Deprecated: use `--style classes`
-    #[arg(long, requires = "html", conflicts_with = "style")]
+    /// When generating HTML, use css classes rather than inline styles
+    #[arg(long)]
     pub css_classes: bool,
-    /// When generating HTML, the document structure to emit
-    #[arg(long, requires = "html", value_enum, default_value = "document")]
-    pub layout: HtmlOutput,
-    /// When generating HTML, how token colors are applied
-    #[arg(long, requires = "html", value_enum, default_value = "classes")]
-    pub style: HtmlStyling,
     /// Check that highlighting captures conform strictly to standards
     #[arg(long)]
     pub check: bool,
     /// The path to a file with captures
-    #[arg(long, requires = "check")]
+    #[arg(long)]
     pub captures_path: Option<PathBuf>,
     /// The paths to files with queries
     #[arg(long, num_args = 1..)]
@@ -554,9 +527,6 @@ struct Highlight {
     /// Force rebuild the parser
     #[arg(short, long)]
     pub rebuild: bool,
-    /// The encoding of the input files
-    #[arg(long)]
-    pub encoding: Option<Encoding>,
 }
 
 #[derive(Args)]
@@ -819,7 +789,7 @@ impl Init {
 
                 let enabled = MultiSelect::new()
                     .with_prompt("Bindings")
-                    .items_checked(languages.iter().copied())
+                    .items_checked(&languages)
                     .interact()?
                     .into_iter()
                     .map(|i| languages[i].0);
@@ -893,7 +863,7 @@ impl Init {
 
                 let idx = FuzzySelect::with_theme(&ColorfulTheme::default())
                     .with_prompt("Which field would you like to change?")
-                    .items(choices)
+                    .items(&choices)
                     .interact()?;
 
                 set_choice!(choices[idx]);
@@ -911,7 +881,7 @@ impl Init {
 
             let new_config = format!("{}\n", serde_json::to_string_pretty(&json)?);
             // Write the re-serialized config back, as newly added optional boolean fields
-            // will be included with explicit `false`s rather than implicit `null`s
+            // will be included with explicit `false`s rather than implict `null`s
             if self.update && !old_config.trim().eq(new_config.trim()) {
                 info!("Updating tree-sitter.json");
                 fs::write(
@@ -958,8 +928,7 @@ impl Generate {
             self.json_summary
         };
 
-        let mut diagnostics = Vec::new();
-        let result = tree_sitter_generate::generate_parser_in_directory(
+        if let Err(err) = tree_sitter_generate::generate_parser_in_directory(
             current_dir,
             self.output.as_deref(),
             self.grammar_path.as_deref(),
@@ -972,33 +941,16 @@ impl Generate {
             } else {
                 OptLevel::default()
             },
-            &mut diagnostics,
-        );
-        if json_summary {
-            #[derive(serde::Serialize)]
-            struct Envelope<'a> {
-                diagnostics: &'a [Diagnostic],
-                error: Option<&'a GenerateError>,
-            }
-            let envelope = Envelope {
-                diagnostics: &diagnostics,
-                error: result.as_ref().err(),
-            };
-            eprintln!("{}", serde_json::to_string_pretty(&envelope)?);
-            if result.is_err() {
+        ) {
+            if json_summary {
+                eprintln!("{}", serde_json::to_string_pretty(&err)?);
                 // Exit early to prevent errors from being printed a second time in the caller
                 std::process::exit(1);
-            }
-        } else {
-            for d in &diagnostics {
-                warn!("{d}");
-            }
-            if let Err(err) = result {
+            } else {
                 // Removes extra context associated with the error
                 Err(anyhow!(err.to_string())).with_context(|| "Error when generating parser")?;
             }
         }
-
         if self.build {
             warn!("--build is deprecated, use the `build` command");
             if let Some(path) = self.libdir {
@@ -1016,7 +968,6 @@ impl Build {
         let grammar_path = current_dir.join(self.path.unwrap_or_default());
 
         loader.debug_build(self.debug);
-        loader.verbose_build(self.verbose);
 
         if self.wasm {
             let output_path = self.output.map(|path| current_dir.join(path));
@@ -1034,7 +985,7 @@ impl Build {
                     .context("Output path must have a parent")?;
                 let name = full_path
                     .file_name()
-                    .context("Output path must have a filename")?;
+                    .context("Ouput path must have a filename")?;
                 fs::create_dir_all(parent_path).context("Failed to create output path")?;
                 let mut canon_path = parent_path.canonicalize().context("Invalid output path")?;
                 canon_path.push(name);
@@ -1072,6 +1023,7 @@ impl Build {
 impl Parse {
     fn run(self, mut loader: loader::Loader, current_dir: &Path) -> Result<()> {
         let config = Config::load(self.config_path)?;
+        let color = env::var("NO_COLOR").map_or(true, |v| v != "1");
         let json_summary = if self.json {
             warn!("--json is deprecated, use --json-summary instead");
             true
@@ -1090,7 +1042,7 @@ impl Parse {
             ParseOutput::Normal
         };
 
-        let parse_theme = if paint::color_enabled() {
+        let parse_theme = if color {
             config
                 .get::<parse::Config>()
                 .with_context(|| "Failed to parse CST theme")?
@@ -1128,6 +1080,9 @@ impl Parse {
         let timeout = self.timeout.unwrap_or_default();
 
         let mut has_error = false;
+        let loader_config = config.get()?;
+        loader.find_all_languages(&loader_config)?;
+
         let should_track_stats = self.stat;
         let mut stats = parse::ParseStats::default();
         let debug: ParseDebugType = match self.debug {
@@ -1170,11 +1125,10 @@ impl Parse {
             has_error |= !parse_result.successful;
         };
 
-        let lib_info = get_lib_info(self.lib_path.as_ref(), self.lang_name.as_ref(), current_dir);
-        if lib_info.is_none() {
-            let loader_config = config.get()?;
-            loader.find_all_languages(&loader_config)?;
+        if self.lib_path.is_none() && self.lang_name.is_some() {
+            warn!("--lang-name` specified without --lib-path. This argument will be ignored.");
         }
+        let lib_info = get_lib_info(self.lib_path.as_ref(), self.lang_name.as_ref(), current_dir);
 
         let input = get_input(
             self.paths_file.as_deref(),
@@ -1325,6 +1279,7 @@ fn check_test(
 impl Test {
     fn run(self, mut loader: loader::Loader, current_dir: &Path) -> Result<()> {
         let config = Config::load(self.config_path)?;
+        let color = env::var("NO_COLOR").map_or(true, |v| v != "1");
         let stat = self.stat.unwrap_or_default();
 
         loader.debug_build(self.debug_build);
@@ -1342,6 +1297,9 @@ impl Test {
             });
         }
 
+        if self.lib_path.is_none() && self.lang_name.is_some() {
+            warn!("--lang-name` specified without --lib-path. This argument will be ignored.");
+        }
         let languages = loader.languages_at_path(current_dir)?;
         let language = if let Some(ref lib_path) = self.lib_path {
             let lib_info =
@@ -1363,9 +1321,13 @@ impl Test {
         parser.set_language(language)?;
 
         let test_dir = current_dir.join("test");
-        let mut test_summary =
-            TestSummary::new(stat, self.update, self.overview_only, self.json_summary);
-        test_summary.use_markers = self.show_diff_markers;
+        let mut test_summary = TestSummary::new(
+            color,
+            stat,
+            self.update,
+            self.overview_only,
+            self.json_summary,
+        );
 
         // Run the corpus tests. Look for them in `test/corpus`.
         let test_corpus_dir = test_dir.join("corpus");
@@ -1380,6 +1342,7 @@ impl Test {
                 update: self.update,
                 open_log: self.open_log,
                 languages: languages.iter().map(|(l, n)| (n.as_str(), l)).collect(),
+                color,
                 show_fields: self.show_fields,
                 overview_only: self.overview_only,
             };
@@ -1390,20 +1353,16 @@ impl Test {
                 self.json_summary,
             )?;
             test_summary.test_num = 1;
-        } else {
-            warn!("Test corpus not found at {}", test_corpus_dir.display());
         }
 
         // Check that all of the queries are valid.
         let query_dir = current_dir.join("queries");
-        if query_dir.is_dir() {
-            check_test(
-                test::check_queries_at_path(language, &query_dir),
-                &test_summary,
-                self.json_summary,
-            )?;
-            test_summary.test_num = 1;
-        }
+        check_test(
+            test::check_queries_at_path(language, &query_dir),
+            &test_summary,
+            self.json_summary,
+        )?;
+        test_summary.test_num = 1;
 
         // Run the syntax highlighting tests.
         let test_highlight_dir = test_dir.join("highlight");
@@ -1446,7 +1405,7 @@ impl Test {
         // For the rest of the queries, find their tests and run them
         for entry in walkdir::WalkDir::new(&query_dir)
             .into_iter()
-            .filter_map(std::result::Result::ok)
+            .filter_map(|e| e.ok())
             .filter(|e| e.file_type().is_file())
         {
             let stem = entry
@@ -1517,6 +1476,9 @@ impl Fuzz {
         loader.sanitize_build(true);
         loader.force_rebuild(self.rebuild || self.grammar_path.is_some());
 
+        if self.lib_path.is_none() && self.lang_name.is_some() {
+            warn!("--lang-name` specified without --lib-path. This argument will be ignored.");
+        }
         let languages = loader.languages_at_path(current_dir)?;
         let (language, language_name) = if let Some(ref lib_path) = self.lib_path {
             let lib_info = get_lib_info(Some(lib_path), self.lang_name.as_ref(), current_dir)
@@ -1564,23 +1526,24 @@ impl Fuzz {
 impl Query {
     fn run(self, mut loader: loader::Loader, current_dir: &Path) -> Result<()> {
         let config = Config::load(self.config_path)?;
-        let lib_info = get_lib_info(self.lib_path.as_ref(), self.lang_name.as_ref(), current_dir);
-        if lib_info.is_none() {
-            let loader_config = config.get()?;
-            loader.find_all_languages(&loader_config)?;
-        }
+        let loader_config = config.get()?;
         loader.force_rebuild(self.rebuild || self.grammar_path.is_some());
+        loader.find_all_languages(&loader_config)?;
         let query_path = Path::new(&self.query_path);
 
-        let byte_range = parse_range(self.byte_range.as_deref(), |x| x)?;
-        let point_range = parse_range(self.row_range.as_deref(), |row| Point::new(row, 0))?;
-        let containing_byte_range = parse_range(self.containing_byte_range.as_deref(), |x| x)?;
-        let containing_point_range = parse_range(self.containing_row_range.as_deref(), |row| {
-            Point::new(row, 0)
-        })?;
+        let byte_range = parse_range(&self.byte_range, |x| x)?;
+        let point_range = parse_range(&self.row_range, |row| Point::new(row, 0))?;
+        let containing_byte_range = parse_range(&self.containing_byte_range, |x| x)?;
+        let containing_point_range =
+            parse_range(&self.containing_row_range, |row| Point::new(row, 0))?;
 
         let cancellation_flag = util::cancel_on_signal();
 
+        if self.lib_path.is_none() && self.lang_name.is_some() {
+            warn!("--lang-name specified without --lib-path. This argument will be ignored.");
+        }
+        let lib_info = get_lib_info(self.lib_path.as_ref(), self.lang_name.as_ref(), current_dir);
+
         let input = get_input(
             self.paths_file.as_deref(),
             self.paths,
@@ -1704,29 +1667,15 @@ impl Highlight {
             }
         }
 
-        let encoding = self.encoding.map(|e| match e {
-            Encoding::Utf8 => ffi::TSInputEncodingUTF8,
-            Encoding::Utf16LE => ffi::TSInputEncodingUTF16LE,
-            Encoding::Utf16BE => ffi::TSInputEncodingUTF16BE,
-        });
-
-        let style = if self.css_classes {
-            // TODO: Remove during the 0.28 release cycle
-            warn!("--css-classes is deprecated, use --style classes instead");
-            HtmlStyling::Classes
-        } else {
-            self.style
-        };
-
         let options = HighlightOptions {
             theme: theme_config.theme,
             check: self.check,
             captures_path: self.captures_path,
-            html: self.html.then_some((self.layout, style)),
+            inline_styles: !self.css_classes,
+            html: self.html,
             quiet: self.quiet,
             print_time: self.time,
             cancellation_flag: cancellation_flag.clone(),
-            encoding,
         };
 
         let input = get_input(
@@ -1811,7 +1760,7 @@ impl Highlight {
                 let path = get_tmp_source_file(&contents)?;
 
                 let (language, language_config) =
-                    if let (Some(l), Some(lc)) = (language, language_configuration) {
+                    if let (Some(l), Some(lc)) = (language.clone(), language_configuration) {
                         (l, lc)
                     } else {
                         let language = languages
@@ -1953,7 +1902,7 @@ impl Tags {
                 let path = get_tmp_source_file(&contents)?;
 
                 let (language, language_config) =
-                    if let (Some(l), Some(lc)) = (language, language_configuration) {
+                    if let (Some(l), Some(lc)) = (language.clone(), language_configuration) {
                         (l, lc)
                     } else {
                         let languages = loader.languages_at_path(current_dir)?;
@@ -2007,7 +1956,7 @@ impl DumpLanguages {
                 concat!(
                     "name: {}\n",
                     "scope: {}\n",
-                    "parser: {}\n",
+                    "parser: {:?}\n",
                     "highlights: {:?}\n",
                     "file_types: {:?}\n",
                     "content_regex: {:?}\n",
@@ -2015,7 +1964,7 @@ impl DumpLanguages {
                 ),
                 configuration.language_name,
                 configuration.scope.as_ref().unwrap_or(&String::new()),
-                language_path.display(),
+                language_path,
                 configuration.highlights_filenames,
                 configuration.file_types,
                 configuration.content_regex,
@@ -2048,10 +1997,10 @@ fn main() {
     let result = run();
     if let Err(err) = &result {
         // Ignore BrokenPipe errors
-        if let Some(error) = err.downcast_ref::<std::io::Error>()
-            && error.kind() == std::io::ErrorKind::BrokenPipe
-        {
-            return;
+        if let Some(error) = err.downcast_ref::<std::io::Error>() {
+            if error.kind() == std::io::ErrorKind::BrokenPipe {
+                return;
+            }
         }
         if !err.to_string().is_empty() {
             error!("{err:?}");
@@ -2104,7 +2053,7 @@ fn run() -> Result<()> {
         | Commands::Complete(_) => &None,
     }
     .as_ref()
-    .map_or_else(|| env::current_dir().unwrap(), std::clone::Clone::clone);
+    .map_or_else(|| env::current_dir().unwrap(), |p| p.clone());
 
     let loader = loader::Loader::new()?;
 
@@ -2176,7 +2125,7 @@ fn get_lib_info<'a>(
         // Use the user-specified name if present, otherwise try to derive it from
         // the lib path
         match (
-            language_name.map(std::string::String::as_str),
+            language_name.map(|s| s.as_str()),
             lib_path.file_stem().and_then(|s| s.to_str()),
         ) {
             (Some(name), _) | (None, Some(name)) => Some((absolute_lib_path, name)),
@@ -2189,10 +2138,10 @@ fn get_lib_info<'a>(
 
 /// Parse a range string of the form "start:end" into an optional Range<T>.
 fn parse_range<T>(
-    range_str: Option<&str>,
+    range_str: &Option<String>,
     make: impl Fn(usize) -> T,
 ) -> Result<Option<std::ops::Range<T>>> {
-    if let Some(range) = range_str {
+    if let Some(range) = range_str.as_ref() {
         let err_msg = format!("Invalid range '{range}', expected 'start:end'");
         let mut parts = range.split(':');
 

crates/cli/src/paint.rs

@@ -1,27 +0,0 @@
-use anstyle::{AnsiColor, Color, Style};
-
-pub const RED: Style = Style::new().fg_color(Some(Color::Ansi(AnsiColor::Red)));
-pub const YELLOW: Style = Style::new().fg_color(Some(Color::Ansi(AnsiColor::Yellow)));
-
-/// Wraps a `Display` value with a style; emits ANSI codes only when
-/// [`color_enabled`] is true.
-pub struct Paint<T>(pub Style, pub T);
-
-pub fn color_enabled() -> bool {
-    static ENABLED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
-    *ENABLED.get_or_init(|| std::env::var_os("NO_COLOR").is_none_or(|v| v.is_empty()))
-}
-
-pub fn paint<T>(color: Option<impl Into<Color>>, text: T) -> Paint<T> {
-    Paint(Style::new().fg_color(color.map(Into::into)), text)
-}
-
-impl<T: std::fmt::Display> std::fmt::Display for Paint<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if color_enabled() {
-            write!(f, "{}{}{:#}", self.0, self.1, self.0)
-        } else {
-            self.1.fmt(f)
-        }
-    }
-}

crates/cli/src/parse.rs

@@ -8,17 +8,17 @@ use std::{
 };
 
 use anstyle::{AnsiColor, Color, RgbColor};
-use anyhow::{Context, Result, anyhow};
+use anyhow::{anyhow, Context, Result};
 use clap::ValueEnum;
 use log::info;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use tree_sitter::{
-    InputEdit, Language, LogType, ParseOptions, ParseState, Parser, Point, Range, Tree, TreeCursor,
-    ffi,
+    ffi, InputEdit, Language, LogType, ParseOptions, ParseState, Parser, Point, Range, Tree,
+    TreeCursor,
 };
 
-use crate::{fuzz::edits::Edit, paint::paint, util};
+use crate::{fuzz::edits::Edit, logger::paint, util};
 
 #[derive(Debug, Default, Serialize, JsonSchema)]
 pub struct Stats {
@@ -286,10 +286,6 @@ pub fn parse_file_at_path(
     max_path_length: usize,
     opts: &mut ParseFileOptions,
 ) -> Result<()> {
-    #[expect(
-        clippy::collection_is_never_read,
-        reason = "value is held for its Drop side effect"
-    )]
     let mut _log_session = None;
     parser.set_language(language)?;
     let mut source_code = fs::read(path).with_context(|| format!("Error reading {name:?}"))?;
@@ -301,6 +297,7 @@ pub fn parse_file_at_path(
     // Log to stderr if `--debug` was passed
     else if opts.debug != ParseDebugType::Quiet {
         let mut curr_version: usize = 0;
+        let use_color = std::env::var("NO_COLOR").map_or(true, |v| v != "1");
         let debug = opts.debug;
         parser.set_logger(Some(Box::new(move |log_type, message| {
             if debug == ParseDebugType::Normal {
@@ -323,21 +320,30 @@ pub fn parse_file_at_path(
                         .parse()
                         .unwrap();
                 }
-                let color = Some(colors[curr_version % colors.len()]);
-                let prefix = if log_type == LogType::Lex { "  " } else { "" };
-                writeln!(&mut io::stderr(), "{prefix}{}", paint(color, message)).unwrap();
+                let color = if use_color {
+                    Some(colors[curr_version % colors.len()])
+                } else {
+                    None
+                };
+                let mut out = if log_type == LogType::Lex {
+                    "  ".to_string()
+                } else {
+                    String::new()
+                };
+                out += &paint(color, message);
+                writeln!(&mut io::stderr(), "{out}").unwrap();
             }
         })));
     }
 
     let parse_time = Instant::now();
 
-    #[inline]
+    #[inline(always)]
     fn is_utf16_le_bom(bom_bytes: &[u8]) -> bool {
         bom_bytes == [0xFF, 0xFE]
     }
 
-    #[inline]
+    #[inline(always)]
     fn is_utf16_be_bom(bom_bytes: &[u8]) -> bool {
         bom_bytes == [0xFE, 0xFF]
     }
@@ -362,13 +368,13 @@ pub fn parse_file_at_path(
     // after the specified number of microseconds.
     let start_time = Instant::now();
     let progress_callback = &mut |_: &ParseState| {
-        if let Some(cancellation_flag) = opts.cancellation_flag
-            && cancellation_flag.load(Ordering::SeqCst) != 0
-        {
-            return ControlFlow::Break(());
+        if let Some(cancellation_flag) = opts.cancellation_flag {
+            if cancellation_flag.load(Ordering::SeqCst) != 0 {
+                return ControlFlow::Break(());
+            }
         }
 
-        if opts.timeout > 0 && start_time.elapsed().as_micros() > u128::from(opts.timeout) {
+        if opts.timeout > 0 && start_time.elapsed().as_micros() > opts.timeout as u128 {
             return ControlFlow::Break(());
         }
 
@@ -380,10 +386,8 @@ pub fn parse_file_at_path(
     let tree = match encoding {
         Some(encoding) if encoding == ffi::TSInputEncodingUTF16LE => {
             let source_code_utf16 = source_code
-                .as_chunks::<2>()
-                .0
-                .iter()
-                .map(|&chunk| u16::from_le_bytes(chunk))
+                .chunks_exact(2)
+                .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
                 .collect::<Vec<_>>();
             parser.parse_utf16_le_with_options(
                 &mut |i, _| {
@@ -399,10 +403,8 @@ pub fn parse_file_at_path(
         }
         Some(encoding) if encoding == ffi::TSInputEncodingUTF16BE => {
             let source_code_utf16 = source_code
-                .as_chunks::<2>()
-                .0
-                .iter()
-                .map(|&chunk| u16::from_be_bytes(chunk))
+                .chunks_exact(2)
+                .map(|chunk| u16::from_be_bytes([chunk[0], chunk[1]]))
                 .collect::<Vec<_>>();
             parser.parse_utf16_be_with_options(
                 &mut |i, _| {
@@ -542,10 +544,10 @@ pub fn parse_file_at_path(
                         }
                         write!(&mut stdout, "</{}>", tag.expect("there is a tag"))?;
                         // we only write a line in the case where it's the last sibling
-                        if let Some(parent) = node.parent()
-                            && parent.child(parent.child_count() - 1).unwrap() == node
-                        {
-                            stdout.write_all(b"\n")?;
+                        if let Some(parent) = node.parent() {
+                            if parent.child(parent.child_count() as u32 - 1).unwrap() == node {
+                                stdout.write_all(b"\n")?;
+                            }
                         }
                         needs_newline = true;
                     }
@@ -774,16 +776,12 @@ pub fn render_cst<'a, 'b: 'a>(
     cursor: &mut TreeCursor<'a>,
     opts: &ParseFileOptions,
     out: &mut impl Write,
-) -> io::Result<()> {
+) -> Result<()> {
     let lossy_source_code = String::from_utf8_lossy(source_code);
     let total_width = lossy_source_code
         .lines()
         .enumerate()
-        .map(|(row, col)| {
-            row.checked_ilog10().unwrap_or(0) as usize
-                + col.len().checked_ilog10().unwrap_or(0) as usize
-                + 1
-        })
+        .map(|(row, col)| (row as f64).log10() as usize + (col.len() as f64).log10() as usize + 1)
         .max()
         .unwrap_or(1);
     let mut indent_level = usize::from(!opts.no_ranges);
@@ -827,19 +825,19 @@ pub fn render_cst<'a, 'b: 'a>(
     Ok(())
 }
 
-struct CstNodeText<'a>(&'a str);
-
-impl std::fmt::Display for CstNodeText<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use std::fmt::Write as _;
-        for c in self.0.chars() {
-            match escape_invisible(c).or_else(|| escape_delimiter(c)) {
-                Some(esc) => f.write_str(esc)?,
-                None => f.write_char(c)?,
+fn render_node_text(source: &str) -> String {
+    source
+        .chars()
+        .fold(String::with_capacity(source.len()), |mut acc, c| {
+            if let Some(esc) = escape_invisible(c) {
+                acc.push_str(esc);
+            } else if let Some(esc) = escape_delimiter(c) {
+                acc.push_str(esc);
+            } else {
+                acc.push(c);
             }
-        }
-        Ok(())
-    }
+            acc
+        })
 }
 
 fn write_node_text(
@@ -850,21 +848,21 @@ fn write_node_text(
     source: &str,
     color: Option<impl Into<Color> + Copy>,
     text_info: (usize, usize),
-) -> io::Result<()> {
+) -> Result<()> {
     let (total_width, indent_level) = text_info;
     let (quote, quote_color) = if is_named {
         ('`', opts.parse_theme.backtick)
     } else {
-        ('\"', color.map(std::convert::Into::into))
+        ('\"', color.map(|c| c.into()))
     };
 
     if !is_named {
         write!(
             out,
             "{}{}{}",
-            paint(quote_color, quote),
-            paint(color, CstNodeText(source)),
-            paint(quote_color, quote),
+            paint(quote_color, &String::from(quote)),
+            paint(color, &render_node_text(source)),
+            paint(quote_color, &String::from(quote)),
         )?;
     } else {
         let multiline = source.contains('\n');
@@ -883,34 +881,24 @@ fn write_node_text(
                 } else {
                     0
                 };
-            if multiline {
-                writeln!(out)?;
-                if !opts.no_ranges {
-                    write!(
-                        out,
-                        "{}",
-                        CstNodeRange {
-                            opts,
-                            has_field_name: cursor.field_name().is_some(),
-                            is_named,
-                            is_multiline: true,
-                            total_width,
-                            range: node_range,
-                        }
-                    )?;
-                }
-                for _ in 0..=indent_level {
-                    write!(out, "  ")?;
-                }
-            } else {
-                write!(out, " ")?;
-            }
+            let formatted_line = render_line_feed(line, opts);
             write!(
                 out,
-                "{}{}{}",
-                paint(quote_color, quote),
-                paint(color, CstLineFeed { source: line, opts }),
-                paint(quote_color, quote),
+                "{}{}{}{}{}{}",
+                if multiline { "\n" } else { " " },
+                if multiline && !opts.no_ranges {
+                    render_node_range(opts, cursor, is_named, true, total_width, node_range)
+                } else {
+                    String::new()
+                },
+                if multiline {
+                    "  ".repeat(indent_level + 1)
+                } else {
+                    String::new()
+                },
+                paint(quote_color, &String::from(quote)),
+                paint(color, &render_node_text(&formatted_line)),
+                paint(quote_color, &String::from(quote)),
             )?;
         }
     }
@@ -918,93 +906,67 @@ fn write_node_text(
     Ok(())
 }
 
-struct CstLineFeed<'src, 'opt> {
-    source: &'src str,
-    opts: &'src ParseFileOptions<'opt>,
-}
-
-impl std::fmt::Display for CstLineFeed<'_, '_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        #[cfg(windows)]
-        let lf = "\r\n";
-        #[cfg(not(windows))]
-        let lf = "\n";
-        let painted = paint(self.opts.parse_theme.line_feed, CstNodeText(lf));
-        let mut parts = self.source.split(lf);
-        if let Some(first) = parts.next() {
-            write!(f, "{}", CstNodeText(first))?;
-        }
-        for part in parts {
-            write!(f, "{painted}{}", CstNodeText(part))?;
-        }
-        Ok(())
+fn render_line_feed(source: &str, opts: &ParseFileOptions) -> String {
+    if cfg!(windows) {
+        source.replace("\r\n", &paint(opts.parse_theme.line_feed, "\r\n"))
+    } else {
+        source.replace('\n', &paint(opts.parse_theme.line_feed, "\n"))
     }
 }
 
-struct CstNodeRange<'src, 'opt> {
-    opts: &'src ParseFileOptions<'opt>,
-    has_field_name: bool,
+fn render_node_range(
+    opts: &ParseFileOptions,
+    cursor: &TreeCursor,
     is_named: bool,
     is_multiline: bool,
     total_width: usize,
     range: Range,
-}
+) -> String {
+    let has_field_name = cursor.field_name().is_some();
+    let range_color = if is_named && !is_multiline && !has_field_name {
+        opts.parse_theme.row_color_named
+    } else {
+        opts.parse_theme.row_color
+    };
 
-impl std::fmt::Display for CstNodeRange<'_, '_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let start = self.range.start_point;
-        let end = self.range.end_point;
-        let range_color = if self.is_named && !self.is_multiline && !self.has_field_name {
-            self.opts.parse_theme.row_color_named
-        } else {
-            self.opts.parse_theme.row_color
-        };
-        let remaining_width = |row: usize, col: usize| {
-            (self
-                .total_width
-                .saturating_sub(row.checked_ilog10().unwrap_or(0) as usize)
-                .saturating_sub(col.checked_ilog10().unwrap_or(0) as usize))
-            .max(1)
-        };
-        let remaining_width_start = remaining_width(start.row, start.column);
-        let remaining_width_end = remaining_width(end.row, end.column);
-        write!(
-            f,
-            "{}",
-            paint(
-                range_color,
-                format_args!(
-                    "{}:{}{:remaining_width_start$}- {}:{}{:remaining_width_end$}",
-                    start.row, start.column, ' ', end.row, end.column, ' ',
-                ),
-            )
-        )
-    }
+    let remaining_width_start = (total_width
+        - (range.start_point.row as f64).log10() as usize
+        - (range.start_point.column as f64).log10() as usize)
+        .max(1);
+    let remaining_width_end = (total_width
+        - (range.end_point.row as f64).log10() as usize
+        - (range.end_point.column as f64).log10() as usize)
+        .max(1);
+    paint(
+        range_color,
+        &format!(
+            "{}:{}{:remaining_width_start$}- {}:{}{:remaining_width_end$}",
+            range.start_point.row,
+            range.start_point.column,
+            ' ',
+            range.end_point.row,
+            range.end_point.column,
+            ' ',
+        ),
+    )
 }
 
 fn cst_render_node(
     opts: &ParseFileOptions,
-    cursor: &TreeCursor,
+    cursor: &mut TreeCursor,
     source_code: &[u8],
     out: &mut impl Write,
     total_width: usize,
     indent_level: usize,
     in_error: bool,
-) -> io::Result<()> {
+) -> Result<()> {
     let node = cursor.node();
     let is_named = node.is_named();
     if !opts.no_ranges {
         write!(
             out,
             "{}",
-            CstNodeRange {
-                opts,
-                has_field_name: cursor.field_name().is_some(),
-                is_named,
-                is_multiline: false,
-                total_width,
-                range: node.range(),
-            }
+            render_node_range(opts, cursor, is_named, false, total_width, node.range())
         )?;
     }
     write!(
@@ -1022,7 +984,7 @@ fn cst_render_node(
             write!(
                 out,
                 "{}",
-                paint(opts.parse_theme.field, format_args!("{field_name}: "))
+                paint(opts.parse_theme.field, &format!("{field_name}: "))
             )?;
         }
 
@@ -1093,13 +1055,10 @@ pub fn perform_edit(tree: &mut Tree, input: &mut Vec<u8>, edit: &Edit) -> Result
 
 fn parse_edit_flag(source_code: &[u8], flag: &str) -> Result<Edit> {
     let error = || {
-        anyhow!(
-            concat!(
-                "Invalid edit string '{}'. ",
-                "Edit strings must match the pattern '<START_BYTE_OR_POSITION> <REMOVED_LENGTH> <NEW_TEXT>'"
-            ),
-            flag
-        )
+        anyhow!(concat!(
+            "Invalid edit string '{}'. ",
+            "Edit strings must match the pattern '<START_BYTE_OR_POSITION> <REMOVED_LENGTH> <NEW_TEXT>'"
+        ), flag)
     };
 
     // Three whitespace-separated parts:
@@ -1137,25 +1096,30 @@ fn parse_edit_flag(source_code: &[u8], flag: &str) -> Result<Edit> {
 
 pub fn offset_for_position(input: &[u8], position: Point) -> Result<usize> {
     let mut row = 0;
-    let mut line_start = 0;
-    for line_end in memchr::memchr_iter(b'\n', input) {
-        if row == position.row {
-            if position.column > line_end - line_start {
-                return Err(anyhow!("Failed to address a column: {}", position.column));
+    let mut offset = 0;
+    let mut iter = memchr::memchr_iter(b'\n', input);
+    loop {
+        if let Some(pos) = iter.next() {
+            if row < position.row {
+                row += 1;
+                offset = pos;
+                continue;
             }
-            return Ok(line_start + position.column);
         }
-        row += 1;
-        line_start = line_end + 1;
+        offset += 1;
+        break;
     }
-
-    if row != position.row {
+    if position.row - row > 0 {
         return Err(anyhow!("Failed to address a row: {}", position.row));
     }
-    if position.column > input.len() - line_start {
+    if let Some(pos) = iter.next() {
+        if (pos - offset < position.column) || (input[offset] == b'\n' && position.column > 0) {
+            return Err(anyhow!("Failed to address a column: {}", position.column));
+        }
+    } else if input.len() - offset < position.column {
         return Err(anyhow!("Failed to address a column over the end"));
     }
-    Ok(line_start + position.column)
+    Ok(offset + position.column)
 }
 
 pub fn position_for_offset(input: &[u8], offset: usize) -> Result<Point> {
@@ -1175,45 +1139,3 @@ pub fn position_for_offset(input: &[u8], offset: usize) -> Result<Point> {
     };
     Ok(result)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::{offset_for_position, parse_edit_flag};
-    use tree_sitter::Point;
-
-    #[test]
-    fn offset_for_position_uses_zero_based_line_and_column_coordinates() {
-        let input = b"abc\n";
-        assert_eq!(
-            offset_for_position(input, Point { row: 0, column: 0 }).unwrap(),
-            0
-        );
-        assert_eq!(
-            offset_for_position(input, Point { row: 0, column: 1 }).unwrap(),
-            1
-        );
-        assert_eq!(
-            offset_for_position(input, Point { row: 0, column: 3 }).unwrap(),
-            3
-        );
-        assert_eq!(
-            offset_for_position(input, Point { row: 1, column: 0 }).unwrap(),
-            4
-        );
-    }
-
-    #[test]
-    fn offset_for_position_rejects_out_of_bounds_coordinates() {
-        let input = b"abc\ndef";
-        assert!(offset_for_position(input, Point { row: 0, column: 4 }).is_err());
-        assert!(offset_for_position(input, Point { row: 2, column: 0 }).is_err());
-    }
-
-    #[test]
-    fn parse_edit_flag_resolves_first_line_positions() {
-        let edit = parse_edit_flag(b"abc\n", "0,0 0 X").unwrap();
-        assert_eq!(edit.position, 0);
-        assert_eq!(edit.deleted_length, 0);
-        assert_eq!(edit.inserted_text, b"X");
-    }
-}

crates/cli/src/playground.html

@@ -19,8 +19,7 @@
         --light-scrollbar-track: #f1f1f1;
         --light-scrollbar-thumb: #c1c1c1;
         --light-scrollbar-thumb-hover: #a8a8a8;
-        --light-tree-row-bg: #e3f2fd;
-        
+
         --dark-bg: #1d1f21;
         --dark-border: #2d2d2d;
         --dark-text: #c5c8c6;
@@ -29,7 +28,6 @@
         --dark-scrollbar-track: #25282c;
         --dark-scrollbar-thumb: #4a4d51;
         --dark-scrollbar-thumb-hover: #5a5d61;
-        --dark-tree-row-bg: #373737;
 
         --primary-color: #0550ae;
         --primary-color-alpha: rgba(5, 80, 174, 0.1);
@@ -44,7 +42,6 @@
         --text-color: var(--dark-text);
         --panel-bg: var(--dark-panel-bg);
         --code-bg: var(--dark-code-bg);
-        --tree-row-bg: var(--dark-tree-row-bg);
       }
 
       [data-theme="light"] {
@@ -53,7 +50,6 @@
         --text-color: var(--light-text);
         --panel-bg: white;
         --code-bg: white;
-        --tree-row-bg: var(--light-tree-row-bg);
       }
 
       /* Base Styles */
@@ -279,7 +275,7 @@
       }
 
       #output-container a.highlighted {
-        background-color: #cae2ff;
+        background-color: #d9d9d9;
         color: red;
         border-radius: 3px;
         text-decoration: underline;
@@ -350,7 +346,7 @@
         }
 
         & #output-container a.highlighted {
-          background-color: #656669;
+          background-color: #373b41;
           color: red;
         }
 
@@ -377,9 +373,6 @@
           color: var(--dark-text);
         }
       }
-      .tree-row:has(.highlighted) {
-        background-color: var(--tree-row-bg); 
-      }
     </style>
   </head>
 
@@ -470,7 +463,7 @@
     <script src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/6.65.7/codemirror.min.js"></script>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/clusterize.js/0.19.0/clusterize.min.js"></script>
 
-    <script>LANGUAGE_BASE_URL = ".";</script>
+    <script>LANGUAGE_BASE_URL = "";</script>
     <script type="module" src="playground.js"></script>
     <script type="module">
       import * as TreeSitter from './web-tree-sitter.js';

crates/cli/src/playground.rs

@@ -3,10 +3,10 @@ use std::{
     env, fs,
     net::TcpListener,
     path::{Path, PathBuf},
-    str::FromStr as _,
+    str::{self, FromStr as _},
 };
 
-use anyhow::{Context, Result, anyhow};
+use anyhow::{anyhow, Context, Result};
 use log::{error, info};
 use tiny_http::{Header, Response, Server};
 

crates/cli/src/query.rs

@@ -75,18 +75,18 @@ pub fn query_file_at_path(
     if opts.ordered_captures {
         let mut captures = query_cursor.captures(&query, tree.root_node(), source_code.as_slice());
         while let Some((mat, capture_index)) = captures.next() {
-            let capture = mat.captures()[*capture_index];
+            let capture = mat.captures[*capture_index];
             let capture_name = &query.capture_names()[capture.index as usize];
             if !opts.quiet && !should_test {
                 writeln!(
-                    &mut stdout,
-                    "    pattern: {:>2}, capture: {} - {capture_name}, start: {}, end: {}, text: `{}`",
-                    mat.pattern_index,
-                    capture.index,
-                    capture.node.start_position(),
-                    capture.node.end_position(),
-                    capture.node.utf8_text(&source_code).unwrap_or("")
-                )?;
+                        &mut stdout,
+                        "    pattern: {:>2}, capture: {} - {capture_name}, start: {}, end: {}, text: `{}`",
+                        mat.pattern_index,
+                        capture.index,
+                        capture.node.start_position(),
+                        capture.node.end_position(),
+                        capture.node.utf8_text(&source_code).unwrap_or("")
+                    )?;
             }
             if should_test {
                 results.push(query_testing::CaptureInfo {
@@ -102,18 +102,18 @@ pub fn query_file_at_path(
             if !opts.quiet && !should_test {
                 writeln!(&mut stdout, "  pattern: {}", m.pattern_index)?;
             }
-            for capture in m.captures() {
+            for capture in m.captures {
                 let start = capture.node.start_position();
                 let end = capture.node.end_position();
                 let capture_name = &query.capture_names()[capture.index as usize];
                 if !opts.quiet && !should_test {
                     if end.row == start.row {
                         writeln!(
-                            &mut stdout,
-                            "    capture: {} - {capture_name}, start: {start}, end: {end}, text: `{}`",
-                            capture.index,
-                            capture.node.utf8_text(&source_code).unwrap_or("")
-                        )?;
+                                &mut stdout,
+                                "    capture: {} - {capture_name}, start: {start}, end: {end}, text: `{}`",
+                                capture.index,
+                                capture.node.utf8_text(&source_code).unwrap_or("")
+                            )?;
                     } else {
                         writeln!(
                             &mut stdout,
@@ -142,9 +142,7 @@ pub fn query_file_at_path(
         };
         // Invariant: `test_summary` will always be `Some` when `should_test` is true
         let test_summary = test_summary.unwrap();
-        let assertions =
-            query_testing::parse_position_comments(&mut parser, language, source_code.as_slice())?;
-        match query_testing::assert_expected_captures(&results, &assertions) {
+        match query_testing::assert_expected_captures(&results, path, &mut parser, language) {
             Ok(assertion_count) => {
                 test_summary.query_results.add_case(TestResult {
                     name: path_name.to_string(),

crates/cli/src/query_testing.rs

@@ -1,6 +1,6 @@
-use std::sync::LazyLock;
+use std::{fs, path::Path, sync::LazyLock};
 
-use anyhow::{Result, anyhow};
+use anyhow::{anyhow, Result};
 use bstr::{BStr, ByteSlice};
 use regex::Regex;
 use tree_sitter::{Language, Parser, Point};
@@ -106,66 +106,66 @@ pub fn parse_position_comments(
             let node = cursor.node();
 
             // Find every comment node.
-            if node.kind().to_lowercase().contains("comment")
-                && let Ok(text) = node.utf8_text(source)
-            {
-                let mut position = node.start_position();
-                if position.row > 0 {
-                    // Find the arrow character ("^" or "<-") in the comment. A left arrow
-                    // refers to the column where the comment node starts. An up arrow refers
-                    // to its own column.
-                    let mut has_left_caret = false;
-                    let mut has_arrow = false;
-                    let mut negative = false;
-                    let mut arrow_end = 0;
-                    let mut arrow_count = 1;
-                    for (i, c) in text.char_indices() {
-                        arrow_end = i + 1;
-                        if c == '-' && has_left_caret {
-                            has_arrow = true;
-                            break;
+            if node.kind().to_lowercase().contains("comment") {
+                if let Ok(text) = node.utf8_text(source) {
+                    let mut position = node.start_position();
+                    if position.row > 0 {
+                        // Find the arrow character ("^" or "<-") in the comment. A left arrow
+                        // refers to the column where the comment node starts. An up arrow refers
+                        // to its own column.
+                        let mut has_left_caret = false;
+                        let mut has_arrow = false;
+                        let mut negative = false;
+                        let mut arrow_end = 0;
+                        let mut arrow_count = 1;
+                        for (i, c) in text.char_indices() {
+                            arrow_end = i + 1;
+                            if c == '-' && has_left_caret {
+                                has_arrow = true;
+                                break;
+                            }
+                            if c == '^' {
+                                has_arrow = true;
+                                position.column += i;
+                                // Continue counting remaining arrows and update their end column
+                                for (_, c) in text[arrow_end..].char_indices() {
+                                    if c != '^' {
+                                        arrow_end += arrow_count - 1;
+                                        break;
+                                    }
+                                    arrow_count += 1;
+                                }
+                                break;
+                            }
+                            has_left_caret = c == '<';
                         }
-                        if c == '^' {
-                            has_arrow = true;
-                            position.column += i;
-                            // Continue counting remaining arrows and update their end column
-                            for (_, c) in text[arrow_end..].char_indices() {
-                                if c != '^' {
-                                    arrow_end += arrow_count - 1;
+
+                        // find any ! after arrows but before capture name
+                        if has_arrow {
+                            for (i, c) in text[arrow_end..].char_indices() {
+                                if c == '!' {
+                                    negative = true;
+                                    arrow_end += i + 1;
+                                    break;
+                                } else if !c.is_whitespace() {
                                     break;
                                 }
-                                arrow_count += 1;
-                            }
-                            break;
-                        }
-                        has_left_caret = c == '<';
-                    }
-
-                    // find any ! after arrows but before capture name
-                    if has_arrow {
-                        for (i, c) in text[arrow_end..].char_indices() {
-                            if c == '!' {
-                                negative = true;
-                                arrow_end += i + 1;
-                                break;
-                            } else if !c.is_whitespace() {
-                                break;
                             }
                         }
-                    }
 
-                    // If the comment node contains an arrow and a highlight name, record the
-                    // highlight name and the position.
-                    if let (true, Some(mat)) =
-                        (has_arrow, CAPTURE_NAME_REGEX.find(&text[arrow_end..]))
-                    {
-                        assertion_ranges.push((node.start_position(), node.end_position()));
-                        result.push(Assertion {
-                            position: to_utf8_point(position, source),
-                            length: arrow_count,
-                            negative,
-                            expected_capture_name: mat.as_str().to_string(),
-                        });
+                        // If the comment node contains an arrow and a highlight name, record the
+                        // highlight name and the position.
+                        if let (true, Some(mat)) =
+                            (has_arrow, CAPTURE_NAME_REGEX.find(&text[arrow_end..]))
+                        {
+                            assertion_ranges.push((node.start_position(), node.end_position()));
+                            result.push(Assertion {
+                                position: to_utf8_point(position, source),
+                                length: arrow_count,
+                                negative,
+                                expected_capture_name: mat.as_str().to_string(),
+                            });
+                        }
                     }
                 }
             }
@@ -219,14 +219,19 @@ pub fn parse_position_comments(
     Ok(result)
 }
 
-pub fn assert_expected_captures(infos: &[CaptureInfo], assertions: &[Assertion]) -> Result<usize> {
-    for assertion in assertions {
+pub fn assert_expected_captures(
+    infos: &[CaptureInfo],
+    path: &Path,
+    parser: &mut Parser,
+    language: &Language,
+) -> Result<usize> {
+    let contents = fs::read_to_string(path)?;
+    let pairs = parse_position_comments(parser, language, contents.as_bytes())?;
+    for assertion in &pairs {
         if let Some(found) = &infos.iter().find(|p| {
-            let assertion_end = Utf8Point::new(
-                assertion.position.row,
-                assertion.position.column + assertion.length - 1,
-            );
-            assertion.position >= p.start && assertion_end < p.end
+            assertion.position >= p.start
+                && (assertion.position.row < p.end.row
+                    || assertion.position.column + assertion.length - 1 < p.end.column)
         }) {
             if assertion.expected_capture_name != found.name && found.name != "name" {
                 return Err(anyhow!(
@@ -245,24 +250,5 @@ pub fn assert_expected_captures(infos: &[CaptureInfo], assertions: &[Assertion])
             ));
         }
     }
-    Ok(assertions.len())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Assertion, CaptureInfo, Utf8Point, assert_expected_captures};
-
-    #[test]
-    fn test_assertion_after_multiline_capture_does_not_match() {
-        let captures = [CaptureInfo {
-            name: "foo".to_string(),
-            start: Utf8Point::new(0, 0),
-            end: Utf8Point::new(1, 1),
-        }];
-        let assertions = [Assertion::new(2, 0, 1, false, "foo".to_string())];
-
-        let result = assert_expected_captures(&captures, &assertions);
-
-        assert!(result.is_err());
-    }
+    Ok(pairs.len())
 }

crates/cli/src/tags.rs

@@ -2,7 +2,8 @@ use std::{
     fs,
     io::{self, Write},
     path::Path,
-    sync::{Arc, atomic::AtomicUsize},
+    str,
+    sync::{atomic::AtomicUsize, Arc},
     time::Instant,
 };
 
@@ -48,7 +49,7 @@ pub fn generate_tags(
                 &mut stdout,
                 "{indent_str}{:<10}\t | {:<8}\t{} {} - {} `{}`",
                 str::from_utf8(&source[tag.name_range]).unwrap_or(""),
-                config.syntax_type_name(tag.syntax_type_id),
+                &config.syntax_type_name(tag.syntax_type_id),
                 if tag.is_definition { "def" } else { "ref" },
                 tag.span.start,
                 tag.span.end,
@@ -58,7 +59,7 @@ pub fn generate_tags(
                 if docs.len() > 120 {
                     write!(&mut stdout, "\t{:?}...", docs.get(0..120).unwrap_or(""))?;
                 } else {
-                    write!(&mut stdout, "\t{docs:?}")?;
+                    write!(&mut stdout, "\t{:?}", &docs)?;
                 }
             }
             writeln!(&mut stdout)?;

crates/cli/src/templates/__init__.py

@@ -1,15 +1,13 @@
 """PARSER_DESCRIPTION"""
 
+from importlib.resources import files as _files
+
 from ._binding import language
 
 
 def _get_query(name, file):
-    files = globals().get("_files")
-    if files is None:
-        from importlib.resources import files
-        globals()["_files"] = files
     try:
-        query = files(f"{__package__}") / file
+        query = _files(f"{__package__}") / file
         globals()[name] = query.read_text()
     except FileNotFoundError:
         globals()[name] = None

crates/cli/src/templates/_cargo.toml

@@ -1,18 +1,25 @@
 [package]
-authors = [ "PARSER_AUTHOR_NAME PARSER_AUTHOR_EMAIL" ]
-autoexamples = false
-categories = [ "parser-implementations", "parsing", "text-editors" ]
-description = "PARSER_DESCRIPTION"
-edition = "2024"
-keywords = [ "incremental", "parsing", "tree-sitter", "PARSER_NAME" ]
-license = "PARSER_LICENSE"
 name = "tree-sitter-PARSER_NAME"
-readme = "README.md"
-repository = "PARSER_URL"
+description = "PARSER_DESCRIPTION"
 version = "PARSER_VERSION"
+authors = ["PARSER_AUTHOR_NAME PARSER_AUTHOR_EMAIL"]
+license = "PARSER_LICENSE"
+readme = "README.md"
+keywords = ["incremental", "parsing", "tree-sitter", "PARSER_NAME"]
+categories = ["parser-implementations", "parsing", "text-editors"]
+repository = "PARSER_URL"
+edition = "2021"
+autoexamples = false
 
 build = "bindings/rust/build.rs"
-include = [ "bindings/rust/*", "grammar.js", "queries/*", "src/*", "tree-sitter.json", "/LICENSE" ]
+include = [
+  "bindings/rust/*",
+  "grammar.js",
+  "queries/*",
+  "src/*",
+  "tree-sitter.json",
+  "/LICENSE",
+]
 
 [lib]
 path = "bindings/rust/lib.rs"

crates/cli/src/templates/build.rs

@@ -11,8 +11,18 @@ fn main() {
         let Ok(wasm_headers) = std::env::var("DEP_TREE_SITTER_LANGUAGE_WASM_HEADERS") else {
             panic!("Environment variable DEP_TREE_SITTER_LANGUAGE_WASM_HEADERS must be set by the language crate");
         };
+        let Ok(wasm_src) =
+            std::env::var("DEP_TREE_SITTER_LANGUAGE_WASM_SRC").map(std::path::PathBuf::from)
+        else {
+            panic!("Environment variable DEP_TREE_SITTER_LANGUAGE_WASM_SRC must be set by the language crate");
+        };
 
         c_config.include(&wasm_headers);
+        c_config.files([
+            wasm_src.join("stdio.c"),
+            wasm_src.join("stdlib.c"),
+            wasm_src.join("string.c"),
+        ]);
     }
 
     let parser_path = src_dir.join("parser.c");

crates/cli/src/templates/build.zig

@@ -4,51 +4,46 @@ pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    var threaded: std.Io.Threaded = .init(b.allocator, .{});
-    defer threaded.deinit();
-    const io = threaded.io();
-
     const shared = b.option(bool, "build-shared", "Build a shared library") orelse true;
     const reuse_alloc = b.option(bool, "reuse-allocator", "Reuse the library allocator") orelse false;
 
     const library_name = "tree-sitter-PARSER_NAME";
 
-    var grammar = b.createModule(.{
-        .target = target,
-        .optimize = optimize,
-        .link_libc = true,
-        .pic = if (shared) true else null,
-    });
     const lib: *std.Build.Step.Compile = b.addLibrary(.{
         .name = library_name,
         .linkage = if (shared) .dynamic else .static,
-        .root_module = grammar,
+        .root_module = b.createModule(.{
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+            .pic = if (shared) true else null,
+        }),
     });
 
-    grammar.addCSourceFile(.{
+    lib.addCSourceFile(.{
         .file = b.path("src/parser.c"),
         .flags = &.{"-std=c11"},
     });
-    if (fileExists(b, io, "src/scanner.c")) {
-        grammar.addCSourceFile(.{
+    if (fileExists(b, "src/scanner.c")) {
+        lib.addCSourceFile(.{
             .file = b.path("src/scanner.c"),
             .flags = &.{"-std=c11"},
         });
     }
 
     if (reuse_alloc) {
-        grammar.addCMacro("TREE_SITTER_REUSE_ALLOCATOR", "");
+        lib.root_module.addCMacro("TREE_SITTER_REUSE_ALLOCATOR", "");
     }
     if (optimize == .Debug) {
-        grammar.addCMacro("TREE_SITTER_DEBUG", "");
+        lib.root_module.addCMacro("TREE_SITTER_DEBUG", "");
     }
 
-    grammar.addIncludePath(b.path("src"));
+    lib.addIncludePath(b.path("src"));
 
     b.installArtifact(lib);
     b.installFile("src/node-types.json", "node-types.json");
 
-    if (fileExists(b, io, "queries")) {
+    if (fileExists(b, "queries")) {
         b.installDirectory(.{
             .source_dir = b.path("queries"),
             .install_dir = .prefix,
@@ -74,10 +69,16 @@ pub fn build(b: *std.Build) !void {
     tests.root_module.addImport(library_name, module);
 
     // HACK: fetch tree-sitter dependency only when testing this module
-    if (b.option(bool, "test", "Fetch test dependencies") orelse false) {
-        const ts_dep = b.lazyDependency("tree_sitter", .{});
-        if (ts_dep) |dep|
-            tests.root_module.addImport("tree-sitter", dep.module("tree_sitter"));
+    if (b.pkg_hash.len == 0) {
+        var args = try std.process.argsWithAllocator(b.allocator);
+        defer args.deinit();
+        while (args.next()) |a| {
+            if (std.mem.eql(u8, a, "test")) {
+                const ts_dep = b.lazyDependency("tree_sitter", .{}) orelse continue;
+                tests.root_module.addImport("tree-sitter", ts_dep.module("tree-sitter"));
+                break;
+            }
+        }
     }
 
     const run_tests = b.addRunArtifact(tests);
@@ -85,8 +86,8 @@ pub fn build(b: *std.Build) !void {
     test_step.dependOn(&run_tests.step);
 }
 
-inline fn fileExists(b: *std.Build, io: std.Io, filename: []const u8) bool {
+inline fn fileExists(b: *std.Build, filename: []const u8) bool {
     const dir = b.build_root.handle;
-    dir.access(io, filename, .{}) catch return false;
+    dir.access(filename, .{}) catch return false;
     return true;
 }

crates/cli/src/templates/build.zig.zon

@@ -1,12 +1,11 @@
 .{
     .name = .tree_sitter_PARSER_NAME,
     .fingerprint = PARSER_FINGERPRINT,
-    .minimum_zig_version = "0.16.0",
     .version = "PARSER_VERSION",
     .dependencies = .{
         .tree_sitter = .{
-            .url = "git+https://github.com/tree-sitter/zig-tree-sitter#0cf58172e61f6fdd16f681cde42b4acb531a23db",
-            .hash = "tree_sitter-0.26.0-8heIf3CaAQDeVTQc0DMSBhbQAEx5aF-dTen4_LPxMgrv",
+            .url = "git+https://github.com/tree-sitter/zig-tree-sitter#b4b72c903e69998fc88e27e154a5e3cc9166551b",
+            .hash = "tree_sitter-0.25.0-8heIf51vAQConvVIgvm-9mVIbqh7yabZYqPXfOpS3YoG",
             .lazy = true,
         },
     },

crates/cli/src/templates/cmakelists.cmake

@@ -17,7 +17,7 @@ endif()
 
 include(GNUInstallDirs)
 
-find_program(TREE_SITTER_CLI tree-sitter DOC "Tree-sitter CLI" REQUIRED)
+find_program(TREE_SITTER_CLI tree-sitter DOC "Tree-sitter CLI")
 
 add_custom_command(OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/src/grammar.json"
                           "${CMAKE_CURRENT_SOURCE_DIR}/src/node-types.json"

crates/cli/src/templates/index.d.ts

@@ -21,7 +21,7 @@ type NodeInfo =
 /**
  * The tree-sitter language object for this grammar.
  *
- * @see {@linkcode https://tree-sitter.github.io/node-tree-sitter/interfaces/Language.html Parser.Language}
+ * @see {@linkcode https://tree-sitter.github.io/node-tree-sitter/interfaces/Parser.Language.html Parser.Language}
  *
  * @example
  * import Parser from "tree-sitter";

crates/cli/src/templates/lib.rs

@@ -20,7 +20,7 @@
 
 use tree_sitter_language::LanguageFn;
 
-unsafe extern "C" {
+extern "C" {
     fn tree_sitter_PARSER_NAME() -> *const ();
 }
 

crates/cli/src/templates/makefile

@@ -1,7 +1,6 @@
 LANGUAGE_NAME := tree-sitter-KEBAB_PARSER_NAME
 HOMEPAGE_URL := PARSER_URL
 VERSION := PARSER_VERSION
-DESCRIPTION := PARSER_DESCRIPTION
 
 # repository
 SRC_DIR := src

crates/cli/src/templates/package.swift

@@ -1,11 +1,10 @@
-// swift-tools-version:5.6
+// swift-tools-version:5.3
 
 import Foundation
 import PackageDescription
 
-let dir = Context.packageDirectory
 var sources = ["src/parser.c"]
-if FileManager.default.fileExists(atPath: "\(dir)/src/scanner.c") {
+if FileManager.default.fileExists(atPath: "src/scanner.c") {
     sources.append("src/scanner.c")
 }
 
@@ -15,7 +14,7 @@ let package = Package(
         .library(name: "PARSER_CLASS_NAME", targets: ["PARSER_CLASS_NAME"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/tree-sitter/swift-tree-sitter", from: "0.10.0"),
+        .package(name: "SwiftTreeSitter", url: "https://github.com/tree-sitter/swift-tree-sitter", from: "0.9.0"),
     ],
     targets: [
         .target(
@@ -32,7 +31,7 @@ let package = Package(
         .testTarget(
             name: "PARSER_CLASS_NAMETests",
             dependencies: [
-                .product(name: "SwiftTreeSitter", package: "swift-tree-sitter"),
+                "SwiftTreeSitter",
                 "PARSER_CLASS_NAME",
             ],
             path: "bindings/swift/PARSER_CLASS_NAMETests"

crates/cli/src/templates/pyproject.toml

@@ -1,29 +1,29 @@
 [build-system]
+requires = ["setuptools>=62.4.0", "wheel"]
 build-backend = "setuptools.build_meta"
-requires = [ "setuptools>=62.4.0", "wheel" ]
 
 [project]
-authors = [ { email = "PARSER_AUTHOR_EMAIL", name = "PARSER_AUTHOR_NAME" } ]
+name = "tree-sitter-PARSER_NAME"
+description = "PARSER_DESCRIPTION"
+version = "PARSER_VERSION"
+keywords = ["incremental", "parsing", "tree-sitter", "PARSER_NAME"]
 classifiers = [
   "Intended Audience :: Developers",
   "Topic :: Software Development :: Compilers",
   "Topic :: Text Processing :: Linguistic",
   "Typing :: Typed",
 ]
-description = "PARSER_DESCRIPTION"
-keywords = [ "incremental", "parsing", "tree-sitter", "PARSER_NAME" ]
-license.text = "PARSER_LICENSE"
-name = "tree-sitter-PARSER_NAME"
-readme = "README.md"
+authors = [{ name = "PARSER_AUTHOR_NAME", email = "PARSER_AUTHOR_EMAIL" }]
 requires-python = ">=3.10"
-version = "PARSER_VERSION"
+license.text = "PARSER_LICENSE"
+readme = "README.md"
 
 [project.urls]
-Funding = "FUNDING_URL"
 Homepage = "PARSER_URL"
+Funding = "FUNDING_URL"
 
 [project.optional-dependencies]
-core = [ "tree-sitter~=0.24" ]
+core = ["tree-sitter~=0.24"]
 
 [tool.cibuildwheel]
 build = "cp310-*"

crates/cli/src/templates/setup.py

@@ -42,7 +42,6 @@ class EggInfo(egg_info):
         super().find_sources()
         self.filelist.recursive_include("queries", "*.scm")
         self.filelist.include("src/tree_sitter/*.h")
-        self.filelist.include("src/*.c")
 
 
 setup(

crates/cli/src/test_highlight.rs

@@ -1,22 +1,22 @@
 use std::{fs, path::Path};
 
-use anyhow::{Result, anyhow};
+use anyhow::{anyhow, Result};
 use tree_sitter::Point;
 use tree_sitter_highlight::{Highlight, HighlightConfiguration, HighlightEvent, Highlighter};
 use tree_sitter_loader::{Config, Loader};
 
 use crate::{
-    query_testing::{Assertion, Utf8Point, parse_position_comments, to_utf8_point},
+    query_testing::{parse_position_comments, to_utf8_point, Assertion, Utf8Point},
     test::{TestInfo, TestOutcome, TestResult, TestSummary},
     util,
 };
 
 #[derive(Debug)]
 pub struct Failure {
-    pub(crate) row: usize,
-    pub(crate) column: usize,
-    pub(crate) expected_highlight: String,
-    pub(crate) actual_highlights: Vec<String>,
+    row: usize,
+    column: usize,
+    expected_highlight: String,
+    actual_highlights: Vec<String>,
 }
 
 impl std::error::Error for Failure {}
@@ -120,9 +120,12 @@ pub fn test_highlights(
         }
     }
 
-    if failed { Err(anyhow!("")) } else { Ok(()) }
+    if failed {
+        Err(anyhow!(""))
+    } else {
+        Ok(())
+    }
 }
-
 pub fn iterate_assertions(
     assertions: &[Assertion],
     highlights: &[(Utf8Point, Utf8Point, Highlight)],
@@ -139,48 +142,49 @@ pub fn iterate_assertions(
         expected_capture_name: expected_highlight,
     } in assertions
     {
-        // Iterate through all of the highlights that start at or before this assertion's
-        // position, looking for one that matches the assertion.
-        actual_highlights.clear();
         let mut passed = false;
-        let end_column = position.column + length - 1;
-        for highlight in &highlights[i..] {
-            // The assertions are ordered by position, so skip past all of the highlights that
-            // end at or before this assertion's position.
+        let mut end_column = position.column + length - 1;
+        actual_highlights.clear();
+
+        // The assertions are ordered by position, so skip past all of the highlights that
+        // end at or before this assertion's position.
+        'highlight_loop: while let Some(highlight) = highlights.get(i) {
             if highlight.1 <= *position {
                 i += 1;
                 continue;
             }
-            if (highlight.0.row > position.row)
-                || (highlight.0.row == position.row && highlight.0.column > end_column)
-            {
-                break;
-            }
 
-            // If the highlight matches the assertion, or if the highlight doesn't
-            // match the assertion but it's negative, this test passes. Otherwise,
-            // add this highlight to the list of actual highlights that span the
-            // assertion's position, in order to generate an error message in the event
-            // of a failure.
-            let highlight_name = &highlight_names[(highlight.2).0];
-            if (*highlight_name == *expected_highlight) == *negative {
-                actual_highlights.push(highlight_name);
-            } else {
-                passed = true;
-                break;
+            // Iterate through all of the highlights that start at or before this assertion's
+            // position, looking for one that matches the assertion.
+            let mut j = i;
+            while let (false, Some(highlight)) = (passed, highlights.get(j)) {
+                end_column = position.column + length - 1;
+                if highlight.0.row >= position.row && highlight.0.column > end_column {
+                    break 'highlight_loop;
+                }
+
+                // If the highlight matches the assertion, or if the highlight doesn't
+                // match the assertion but it's negative, this test passes. Otherwise,
+                // add this highlight to the list of actual highlights that span the
+                // assertion's position, in order to generate an error message in the event
+                // of a failure.
+                let highlight_name = &highlight_names[(highlight.2).0];
+                if (*highlight_name == *expected_highlight) == *negative {
+                    actual_highlights.push(highlight_name);
+                } else {
+                    passed = true;
+                    break 'highlight_loop;
+                }
+
+                j += 1;
             }
         }
 
         if !passed {
-            let mut expected = String::with_capacity(expected_highlight.len() + 1);
-            if *negative {
-                expected.push('!');
-            }
-            expected.push_str(expected_highlight);
             return Err(Failure {
                 row: position.row,
                 column: end_column,
-                expected_highlight: expected,
+                expected_highlight: expected_highlight.clone(),
                 actual_highlights: actual_highlights.into_iter().cloned().collect(),
             }
             .into());
@@ -219,11 +223,9 @@ pub fn get_highlight_positions(
     let mut highlight_stack = Vec::new();
     let source = String::from_utf8_lossy(source);
     let mut char_indices = source.char_indices();
-    for event in
-        highlighter.highlight(highlight_config, source.as_bytes(), None, None, |string| {
-            loader.highlight_config_for_injection_string(string)
-        })?
-    {
+    for event in highlighter.highlight(highlight_config, source.as_bytes(), None, |string| {
+        loader.highlight_config_for_injection_string(string)
+    })? {
         match event? {
             HighlightEvent::HighlightStart(h) => highlight_stack.push(h),
             HighlightEvent::HighlightEnd => {

crates/cli/src/test_tags.rs

@@ -1,11 +1,11 @@
 use std::{fs, path::Path};
 
-use anyhow::{Result, anyhow};
+use anyhow::{anyhow, Result};
 use tree_sitter_loader::{Config, Loader};
 use tree_sitter_tags::{TagsConfiguration, TagsContext};
 
 use crate::{
-    query_testing::{Assertion, Utf8Point, parse_position_comments, to_utf8_point},
+    query_testing::{parse_position_comments, to_utf8_point, Assertion, Utf8Point},
     test::{TestInfo, TestOutcome, TestResult, TestSummary},
     util,
 };
@@ -113,7 +113,11 @@ pub fn test_tags(
         }
     }
 
-    if failed { Err(anyhow!("")) } else { Ok(()) }
+    if failed {
+        Err(anyhow!(""))
+    } else {
+        Ok(())
+    }
 }
 
 pub fn test_tag(

crates/cli/src/tests.rs

@@ -17,12 +17,13 @@ mod tree_test;
 #[cfg(feature = "wasm")]
 mod wasm_language_test;
 
-use tree_sitter_generate::{GenerateResult, OptLevel};
+use tree_sitter_generate::GenerateResult;
 
 pub use crate::fuzz::{
-    ITERATION_COUNT, allocations,
+    allocations,
     edits::{get_random_edit, invert_edit},
     random::Rand,
+    ITERATION_COUNT,
 };
 
 pub use helpers::fixtures::get_language;
@@ -30,10 +31,5 @@ pub use helpers::fixtures::get_language;
 /// This is a simple wrapper around [`tree_sitter_generate::generate_parser_for_grammar`], because
 /// our tests do not need to pass in a version number, only the grammar JSON.
 fn generate_parser(grammar_json: &str) -> GenerateResult<(String, String)> {
-    tree_sitter_generate::generate_parser_for_grammar(
-        grammar_json,
-        Some((0, 0, 0)),
-        OptLevel::default(),
-        &mut Vec::new(),
-    )
+    tree_sitter_generate::generate_parser_for_grammar(grammar_json, Some((0, 0, 0)))
 }

crates/cli/src/tests/corpus_test.rs

@@ -2,25 +2,24 @@ use std::{collections::HashMap, env, fs};
 
 use anyhow::Context;
 use tree_sitter::Parser;
-use tree_sitter_generate::OptLevel;
 use tree_sitter_proc_macro::test_with_seed;
 
 use crate::{
     fuzz::{
-        EDIT_COUNT, EXAMPLE_EXCLUDE, EXAMPLE_INCLUDE, ITERATION_COUNT, LANGUAGE_FILTER,
-        LOG_GRAPH_ENABLED, START_SEED,
         corpus_test::{
             check_changed_ranges, check_consistent_sizes, get_parser, set_included_ranges,
         },
         edits::{get_random_edit, invert_edit},
         flatten_tests, new_seed,
         random::Rand,
+        EDIT_COUNT, EXAMPLE_EXCLUDE, EXAMPLE_INCLUDE, ITERATION_COUNT, LANGUAGE_FILTER,
+        LOG_GRAPH_ENABLED, START_SEED,
     },
     parse::perform_edit,
-    test::{DiffKey, TestDiff, parse_tests, render_test_output},
+    test::{parse_tests, strip_sexp_fields, DiffKey, TestDiff},
     tests::{
         allocations,
-        helpers::fixtures::{SCRATCH_BASE_DIR, fixtures_dir, get_language, get_test_language},
+        helpers::fixtures::{fixtures_dir, get_language, get_test_language, SCRATCH_BASE_DIR},
     },
 };
 
@@ -121,10 +120,10 @@ pub fn test_language_corpus(
     skipped: Option<&[&str]>,
     language_dir: Option<&str>,
 ) {
-    if let Some(filter) = LANGUAGE_FILTER.as_ref()
-        && language_name != filter
-    {
-        return;
+    if let Some(filter) = LANGUAGE_FILTER.as_ref() {
+        if language_name != filter {
+            return;
+        }
     }
 
     let language_dir = language_dir.unwrap_or_default();
@@ -186,17 +185,38 @@ pub fn test_language_corpus(
     println!();
     for (test_index, test) in tests.iter().enumerate() {
         let test_name = format!("{language_name} - {}", test.name);
-        if let Some(skipped) = skipped.as_mut()
-            && let Some(counter) = skipped.get_mut(test_name.as_str())
-        {
-            println!("  {test_index}. {test_name} - SKIPPED");
-            *counter += 1;
-            continue;
+        if let Some(skipped) = skipped.as_mut() {
+            if let Some(counter) = skipped.get_mut(test_name.as_str()) {
+                println!("  {test_index}. {test_name} - SKIPPED");
+                *counter += 1;
+                continue;
+            }
         }
 
         println!("  {test_index}. {test_name}");
 
-        let passed = allocations::record(|| test.check_initial_parse(&language, &test_name, true));
+        let passed = allocations::record(|| {
+            let mut log_session = None;
+            let mut parser = get_parser(&mut log_session, "log.html");
+            parser.set_language(&language).unwrap();
+            set_included_ranges(&mut parser, &test.input, test.template_delimiters);
+
+            let tree = parser.parse(&test.input, None).unwrap();
+            let mut actual_output = tree.root_node().to_sexp();
+            if !test.has_fields {
+                actual_output = strip_sexp_fields(&actual_output);
+            }
+
+            if actual_output != test.output {
+                println!("Incorrect initial parse for {test_name}");
+                DiffKey::print();
+                println!("{}", TestDiff::new(&actual_output, &test.output));
+                println!();
+                return false;
+            }
+
+            true
+        });
 
         if !passed {
             failure_count += 1;
@@ -254,9 +274,7 @@ pub fn test_language_corpus(
                 // Check that the new tree is consistent.
                 check_consistent_sizes(&tree2, &input);
                 if let Err(message) = check_changed_ranges(&tree, &tree2, &input) {
-                    println!(
-                        "\nUnexpected scope change in seed {seed} with start seed {start_seed}\n{message}\n\n",
-                    );
+                    println!("\nUnexpected scope change in seed {seed} with start seed {start_seed}\n{message}\n\n");
                     return false;
                 }
 
@@ -272,8 +290,10 @@ pub fn test_language_corpus(
                 let tree3 = parser.parse(&input, Some(&tree2)).unwrap();
 
                 // Verify that the final tree matches the expectation from the corpus.
-                let actual_output =
-                    render_test_output(&input, &tree3, test.cst, test.has_fields).unwrap();
+                let mut actual_output = tree3.root_node().to_sexp();
+                if !test.has_fields {
+                    actual_output = strip_sexp_fields(&actual_output);
+                }
 
                 if actual_output != test.output {
                     println!("Incorrect parse for {test_name} - seed {seed}");
@@ -286,9 +306,7 @@ pub fn test_language_corpus(
                 // Check that the edited tree is consistent.
                 check_consistent_sizes(&tree3, &input);
                 if let Err(message) = check_changed_ranges(&tree2, &tree3, &input) {
-                    println!(
-                        "Unexpected scope change in seed {seed} with start seed {start_seed}\n{message}\n\n"
-                    );
+                    println!("Unexpected scope change in seed {seed} with start seed {start_seed}\n{message}\n\n");
                     return false;
                 }
 
@@ -333,10 +351,10 @@ fn test_feature_corpus_files() {
         let language_name = entry.file_name();
         let language_name = language_name.to_str().unwrap();
 
-        if let Some(filter) = LANGUAGE_FILTER.as_ref()
-            && language_name != filter
-        {
-            continue;
+        if let Some(filter) = LANGUAGE_FILTER.as_ref() {
+            if language_name != filter {
+                continue;
+            }
         }
 
         let test_path = entry.path();
@@ -353,12 +371,8 @@ fn test_feature_corpus_files() {
                 )
             })
             .unwrap();
-        let generate_result = tree_sitter_generate::generate_parser_for_grammar(
-            &grammar_json,
-            Some((0, 0, 0)),
-            OptLevel::default(),
-            &mut Vec::new(),
-        );
+        let generate_result =
+            tree_sitter_generate::generate_parser_for_grammar(&grammar_json, Some((0, 0, 0)));
 
         if error_message_path.exists() {
             if EXAMPLE_INCLUDE.is_some() || EXAMPLE_EXCLUDE.is_some() {
@@ -402,8 +416,24 @@ fn test_feature_corpus_files() {
             for test in tests {
                 eprintln!("  example: {:?}", test.name);
 
-                let passed =
-                    allocations::record(|| test.check_initial_parse(&language, &test.name, true));
+                let passed = allocations::record(|| {
+                    let mut log_session = None;
+                    let mut parser = get_parser(&mut log_session, "log.html");
+                    parser.set_language(&language).unwrap();
+                    let tree = parser.parse(&test.input, None).unwrap();
+                    let mut actual_output = tree.root_node().to_sexp();
+                    if !test.has_fields {
+                        actual_output = strip_sexp_fields(&actual_output);
+                    }
+                    if actual_output == test.output {
+                        true
+                    } else {
+                        DiffKey::print();
+                        print!("{}", TestDiff::new(&actual_output, &test.output));
+                        println!();
+                        false
+                    }
+                });
 
                 if !passed {
                     failure_count += 1;

crates/cli/src/tests/helpers/edits.rs

@@ -1,4 +1,4 @@
-use std::ops::Range;
+use std::{ops::Range, str};
 
 #[derive(Debug)]
 pub struct ReadRecorder<'a> {
@@ -20,7 +20,7 @@ impl<'a> ReadRecorder<'a> {
             if let Err(i) = self.indices_read.binary_search(&offset) {
                 self.indices_read.insert(i, offset);
             }
-            &self.content[offset..=offset]
+            &self.content[offset..(offset + 1)]
         } else {
             &[]
         }
@@ -30,7 +30,7 @@ impl<'a> ReadRecorder<'a> {
         let mut result = Vec::new();
         let mut last_range = Option::<Range<usize>>::None;
         for index in &self.indices_read {
-            if let Some(range) = &mut last_range {
+            if let Some(ref mut range) = &mut last_range {
                 if range.end == *index {
                     range.end += 1;
                 } else {

crates/cli/src/tests/helpers/fixtures.rs

@@ -1,13 +1,12 @@
 use std::{
-    collections::HashSet,
     env, fs,
     path::{Path, PathBuf},
-    sync::{LazyLock, Mutex},
+    sync::LazyLock,
 };
 
 use anyhow::Context;
 use tree_sitter::Language;
-use tree_sitter_generate::{ALLOC_HEADER, ARRAY_HEADER, load_grammar_file};
+use tree_sitter_generate::{load_grammar_file, ALLOC_HEADER, ARRAY_HEADER};
 use tree_sitter_highlight::HighlightConfiguration;
 use tree_sitter_loader::{CompileConfig, Loader};
 use tree_sitter_tags::TagsConfiguration;
@@ -24,10 +23,6 @@ static TEST_LOADER: LazyLock<Loader> = LazyLock::new(|| {
     loader
 });
 
-// Prevents parallel tests from racing on the same per-grammar
-// `src_dir/tree_sitter/` and observing a half-rewritten header.
-static WRITTEN_HEADER_DIRS: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(Default::default);
-
 #[cfg(feature = "wasm")]
 pub static ENGINE: LazyLock<tree_sitter::wasmtime::Engine> = LazyLock::new(Default::default);
 
@@ -139,22 +134,17 @@ fn get_test_language_internal(
     };
 
     let header_path = src_dir.join("tree_sitter");
-    if WRITTEN_HEADER_DIRS
-        .lock()
-        .unwrap()
-        .insert(header_path.clone())
-    {
-        fs::create_dir_all(&header_path).unwrap();
-        for (file, content) in [
-            ("alloc.h", ALLOC_HEADER),
-            ("array.h", ARRAY_HEADER),
-            ("parser.h", tree_sitter::PARSER_HEADER),
-        ] {
-            let path = header_path.join(file);
-            fs::write(&path, content)
-                .with_context(|| format!("Failed to write {}", path.display()))
-                .unwrap();
-        }
+    fs::create_dir_all(&header_path).unwrap();
+
+    for (file, content) in [
+        ("alloc.h", ALLOC_HEADER),
+        ("array.h", ARRAY_HEADER),
+        ("parser.h", tree_sitter::PARSER_HEADER),
+    ] {
+        let file = header_path.join(file);
+        fs::write(&file, content)
+            .with_context(|| format!("Failed to write {:?}", file.file_name().unwrap()))
+            .unwrap();
     }
 
     let paths_to_check = if let Some(scanner_path) = &scanner_path {

crates/cli/src/tests/helpers/query_helpers.rs

@@ -1,16 +1,16 @@
 use std::{cmp::Ordering, fmt::Write, ops::Range};
 
-use rand::{Rng, RngExt};
+use rand::prelude::Rng;
 use streaming_iterator::{IntoStreamingIterator, StreamingIterator};
 use tree_sitter::{
     Language, Node, Parser, Point, Query, QueryCapture, QueryCursor, QueryMatch, Tree, TreeCursor,
 };
 
 #[derive(Debug)]
-pub struct Pattern<'a> {
-    kind: Option<&'a str>,
+pub struct Pattern {
+    kind: Option<&'static str>,
     named: bool,
-    field: Option<&'a str>,
+    field: Option<&'static str>,
     capture: Option<String>,
     children: Vec<Self>,
 }
@@ -25,17 +25,17 @@ const CAPTURE_NAMES: &[&str] = &[
     "one", "two", "three", "four", "five", "six", "seven", "eight",
 ];
 
-impl<'a> Pattern<'a> {
-    pub fn random_pattern_in_tree(tree: &'a Tree, rng: &mut impl Rng) -> (Self, Range<Point>) {
+impl Pattern {
+    pub fn random_pattern_in_tree(tree: &Tree, rng: &mut impl Rng) -> (Self, Range<Point>) {
         let mut cursor = tree.walk();
 
         // Descend to the node at a random byte offset and depth.
         let mut max_depth = 0;
-        let byte_offset = rng.random_range(0..cursor.node().end_byte());
+        let byte_offset = rng.gen_range(0..cursor.node().end_byte());
         while cursor.goto_first_child_for_byte(byte_offset).is_some() {
             max_depth += 1;
         }
-        let depth = rng.random_range(0..=max_depth);
+        let depth = rng.gen_range(0..=max_depth);
         for _ in 0..depth {
             cursor.goto_parent();
         }
@@ -45,7 +45,7 @@ impl<'a> Pattern<'a> {
         let pattern_start = cursor.node().start_position();
         let mut roots = vec![Self::random_pattern_for_node(&mut cursor, rng)];
         while roots.len() < 5 && cursor.goto_next_sibling() {
-            if rng.random_bool(0.2) {
+            if rng.gen_bool(0.2) {
                 roots.push(Self::random_pattern_for_node(&mut cursor, rng));
             }
         }
@@ -75,26 +75,26 @@ impl<'a> Pattern<'a> {
         (pattern, pattern_start..pattern_end)
     }
 
-    fn random_pattern_for_node(cursor: &mut TreeCursor<'a>, rng: &mut impl Rng) -> Self {
+    fn random_pattern_for_node(cursor: &mut TreeCursor, rng: &mut impl Rng) -> Self {
         let node = cursor.node();
 
         // Sometimes specify the node's type, sometimes use a wildcard.
-        let (kind, named) = if rng.random_bool(0.9) {
+        let (kind, named) = if rng.gen_bool(0.9) {
             (Some(node.kind()), node.is_named())
         } else {
-            (Some("_"), node.is_named() && rng.random_bool(0.8))
+            (Some("_"), node.is_named() && rng.gen_bool(0.8))
         };
 
         // Sometimes specify the node's field.
-        let field = if rng.random_bool(0.75) {
+        let field = if rng.gen_bool(0.75) {
             cursor.field_name()
         } else {
             None
         };
 
         // Sometimes capture the node.
-        let capture = if rng.random_bool(0.7) {
-            Some(CAPTURE_NAMES[rng.random_range(0..CAPTURE_NAMES.len())].to_string())
+        let capture = if rng.gen_bool(0.7) {
+            Some(CAPTURE_NAMES[rng.gen_range(0..CAPTURE_NAMES.len())].to_string())
         } else {
             None
         };
@@ -102,9 +102,9 @@ impl<'a> Pattern<'a> {
         // Walk the children and include child patterns for some of them.
         let mut children = Vec::new();
         if named && cursor.goto_first_child() {
-            let max_children = rng.random_range(0..4);
+            let max_children = rng.gen_range(0..4);
             while cursor.goto_next_sibling() {
-                if rng.random_bool(0.6) {
+                if rng.gen_bool(0.6) {
                     let child_ast = Self::random_pattern_for_node(cursor, rng);
                     children.push(child_ast);
                     if children.len() >= max_children {
@@ -204,10 +204,10 @@ impl<'a> Pattern<'a> {
         }
 
         // If a field is specified, check that it matches the node.
-        if let Some(field) = self.field
-            && cursor.field_name() != Some(field)
-        {
-            return Vec::new();
+        if let Some(field) = self.field {
+            if cursor.field_name() != Some(field) {
+                return Vec::new();
+            }
         }
 
         // Create a match for the current node.
@@ -225,7 +225,7 @@ impl<'a> Pattern<'a> {
         }
 
         // Find every matching combination of child patterns and child nodes.
-        let mut finished_matches = Vec::<Match<'_, 'tree>>::new();
+        let mut finished_matches = Vec::<Match>::new();
         if cursor.goto_first_child() {
             let mut match_states = vec![(0, mat)];
             loop {
@@ -268,7 +268,7 @@ impl<'a> Pattern<'a> {
     }
 }
 
-impl std::fmt::Display for Pattern<'_> {
+impl std::fmt::Display for Pattern {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut result = String::new();
         self.write_to_string(&mut result, 0);
@@ -336,7 +336,7 @@ pub fn collect_matches<'a>(
     while let Some(m) = matches.next() {
         result.push((
             m.pattern_index,
-            format_captures(m.captures().iter().into_streaming_iter_ref(), query, source),
+            format_captures(m.captures.iter().into_streaming_iter_ref(), query, source),
         ));
     }
     result
@@ -347,7 +347,7 @@ pub fn collect_captures<'a>(
     query: &'a Query,
     source: &'a str,
 ) -> Vec<(&'a str, &'a str)> {
-    format_captures(captures.map(|(m, i)| m.captures()[*i]), query, source)
+    format_captures(captures.map(|(m, i)| m.captures[*i]), query, source)
 }
 
 fn format_captures<'a>(

crates/cli/src/tests/highlight_test.rs

@@ -2,15 +2,15 @@ use std::{
     ffi::CString,
     fs,
     os::raw::c_char,
-    ptr, slice,
+    ptr, slice, str,
     sync::{
-        LazyLock,
         atomic::{AtomicUsize, Ordering},
+        LazyLock,
     },
 };
 
 use tree_sitter_highlight::{
-    Error, Highlight, HighlightConfiguration, HighlightEvent, Highlighter, HtmlRenderer, c,
+    c, Error, Highlight, HighlightConfiguration, HighlightEvent, Highlighter, HtmlRenderer,
 };
 
 use super::helpers::fixtures::{get_highlight_config, get_language, get_language_queries_path};
@@ -485,7 +485,6 @@ fn test_highlighting_cancellation() {
         .highlight(
             &HTML_HIGHLIGHT,
             source.as_bytes(),
-            None,
             Some(&cancellation_flag),
             injection_callback,
         )
@@ -496,7 +495,7 @@ fn test_highlighting_cancellation() {
     let found_cancellation_error = events.any(|event| match event {
         Ok(_) => false,
         Err(Error::Cancelled) => true,
-        Err(Error::InvalidLanguage(_) | Error::Unknown) => {
+        Err(Error::InvalidLanguage | Error::Unknown) => {
             unreachable!("Unexpected error type while iterating events")
         }
     });
@@ -728,7 +727,6 @@ fn to_html<'a>(
         language_config,
         src,
         None,
-        None,
         &test_language_for_injection_string,
     )?;
 
@@ -749,10 +747,7 @@ fn to_html<'a>(
         .collect())
 }
 
-#[expect(
-    clippy::type_complexity,
-    reason = "return type represents structured highlight tokens"
-)]
+#[allow(clippy::type_complexity)]
 fn to_token_vector<'a>(
     src: &'a str,
     language_config: &'a HighlightConfiguration,
@@ -766,7 +761,6 @@ fn to_token_vector<'a>(
         language_config,
         src,
         None,
-        None,
         &test_language_for_injection_string,
     )?;
     for event in events {

crates/cli/src/tests/language_test.rs

@@ -31,17 +31,14 @@ fn test_lookahead_iterator() {
     let mut lookahead = language.lookahead_iterator(next_state).unwrap();
     assert_eq!(*lookahead.language(), language);
     assert!(lookahead.iter_names().eq(expected_symbols));
-    assert_eq!(lookahead.iter_names().count(), 0);
 
-    assert!(lookahead.reset_state(next_state));
+    lookahead.reset_state(next_state);
     assert!(lookahead.iter_names().eq(expected_symbols));
 
-    assert!(lookahead.reset(&language, next_state));
-    assert!(
-        lookahead
-            .map(|s| language.node_kind_for_id(s).unwrap())
-            .eq(expected_symbols)
-    );
+    lookahead.reset(&language, next_state);
+    assert!(lookahead
+        .map(|s| language.node_kind_for_id(s).unwrap())
+        .eq(expected_symbols));
 }
 
 #[test]
@@ -67,33 +64,6 @@ fn test_lookahead_iterator_modifiable_only_by_mut() {
     let _ = names.next();
 }
 
-#[test]
-fn test_lookahead_iterator_exhaustion() {
-    let language = get_language("json");
-
-    for state in 0..language.parse_state_count() {
-        let state = u16::try_from(state).unwrap();
-        let mut lookahead = language.lookahead_iterator(state).unwrap();
-
-        // A fresh iterator is not positioned on a symbol.
-        assert_eq!(lookahead.current_symbol(), None);
-        assert_eq!(lookahead.current_symbol_name(), None);
-
-        let count = lookahead.by_ref().count();
-
-        // An exhausted iterator is not positioned on a symbol, and stays exhausted.
-        assert_eq!(lookahead.current_symbol(), None);
-        assert_eq!(lookahead.current_symbol_name(), None);
-        assert_eq!(lookahead.by_ref().count(), 0);
-        assert_eq!(lookahead.iter_names().count(), 0);
-
-        // Resetting restores it exactly.
-        assert!(lookahead.reset_state(state));
-        assert_eq!(lookahead.current_symbol(), None);
-        assert_eq!(lookahead.by_ref().count(), count);
-    }
-}
-
 #[test]
 fn test_symbol_metadata_checks() {
     let language = get_language("rust");
@@ -140,7 +110,7 @@ fn test_supertypes() {
         supertypes
             .iter()
             .filter_map(|&s| language.node_kind_for_id(s))
-            .map(std::string::ToString::to_string)
+            .map(|s| s.to_string())
             .collect::<Vec<String>>(),
         vec![
             "_expression",

crates/cli/src/tests/node_test.rs

@@ -2,8 +2,9 @@ use tree_sitter::{InputEdit, Node, Parser, Point, Tree};
 use tree_sitter_generate::load_grammar_file;
 
 use super::{
-    Rand, get_random_edit,
+    get_random_edit,
     helpers::fixtures::{fixtures_dir, get_language, get_test_language},
+    Rand,
 };
 use crate::{
     parse::perform_edit,
@@ -285,10 +286,7 @@ fn test_parent_of_zero_width_node() {
 
     assert_eq!(block.to_string(), "(block)");
     assert_eq!(block_parent.kind(), "function_definition");
-    assert_eq!(
-        block_parent.to_string(),
-        "(function_definition name: (identifier) parameters: (parameters (identifier)) body: (block))"
-    );
+    assert_eq!(block_parent.to_string(), "(function_definition name: (identifier) parameters: (parameters (identifier)) body: (block))");
 
     assert_eq!(
         root.child_with_descendant(block).unwrap(),
@@ -454,7 +452,7 @@ fn test_node_child_by_field_name_with_extra_hidden_children() {
     // In the Python grammar, some fields are applied to `suite` nodes,
     // which consist of an invisible `indent` token followed by a block.
     // Check that when searching for a child with a field name, we don't
-    // return a hidden child node.
+    //
     let tree = parser.parse("while a:\n  pass", None).unwrap();
     let while_node = tree.root_node().child(0).unwrap();
     assert_eq!(while_node.kind(), "while_statement");
@@ -950,13 +948,6 @@ fn test_node_sexp() {
 
 #[test]
 fn test_node_field_names() {
-    // - "x":
-    //      This isn't used in the test, but prevents `_hidden_rule1` from being eliminated as a
-    //      unit reduction.
-    // - "_hidden_rule1":
-    //      Fields pointing to hidden nodes with a single child resolve to the child.
-    // - "_hidden_rule2":
-    //      Fields within hidden nodes can be referenced through the parent node.
     let (parser_name, parser_code) = generate_parser(
         r#"
         {
@@ -979,6 +970,8 @@ fn test_node_field_names() {
                                 {"type": "STRING", "value": "child-1"},
                                 {"type": "BLANK"},
 
+                                // This isn't used in the test, but prevents `_hidden_rule1`
+                                // from being eliminated as a unit reduction.
                                 {
                                     "type": "ALIAS",
                                     "value": "x",
@@ -999,6 +992,7 @@ fn test_node_field_names() {
                     ]
                 },
 
+                // Fields pointing to hidden nodes with a single child resolve to the child.
                 "_hidden_rule1": {
                     "type": "CHOICE",
                     "members": [
@@ -1007,6 +1001,7 @@ fn test_node_field_names() {
                     ]
                 },
 
+                // Fields within hidden nodes can be referenced through the parent node.
                 "_hidden_rule2": {
                     "type": "SEQ",
                     "members": [

crates/cli/src/tests/parser_test.rs

@@ -66,13 +66,9 @@ fn test_parsing_with_logging() {
     parser.set_language(&get_language("rust")).unwrap();
 
     let mut messages = Vec::new();
-    // SAFETY: the logger borrows `messages` and is only invoked during the
-    // `parse` call below while `messages` is in scope.
-    unsafe {
-        parser.set_logger_unchecked(Some(Box::new(|log_type, message| {
-            messages.push((log_type, message.to_string()));
-        })));
-    }
+    parser.set_logger(Some(Box::new(|log_type, message| {
+        messages.push((log_type, message.to_string()));
+    })));
 
     parser
         .parse(
@@ -253,21 +249,6 @@ fn test_parsing_with_custom_utf16_be_input() {
     assert_eq!(root.child(0).unwrap().kind(), "function_item");
 }
 
-#[test]
-fn test_utf16_decodes_surrogate_pairs() {
-    let mut parser = Parser::new();
-    let language = get_test_fixture_language("utf16_surrogate_oob");
-    parser.set_language(&language).unwrap();
-
-    let le = [0xD83D_u16.to_le(), 0xDE00_u16.to_le()];
-    let tree = parser.parse_utf16_le(le, None).unwrap();
-    assert_eq!(tree.root_node().to_sexp(), "(program (supplementary))");
-
-    let be = [0xD83D_u16.to_be(), 0xDE00_u16.to_be()];
-    let tree = parser.parse_utf16_be(be, None).unwrap();
-    assert_eq!(tree.root_node().to_sexp(), "(program (supplementary))");
-}
-
 #[test]
 fn test_utf16_decode_does_not_read_oob() {
     // Test for a buffer over-read in ts_decode_utf16_le/be when a lead surrogate
@@ -822,7 +803,11 @@ fn test_parsing_cancelled_by_another_thread() {
         &mut |offset, _| {
             thread::yield_now();
             thread::sleep(time::Duration::from_millis(10));
-            if offset == 0 { b" [" } else { b"0," }
+            if offset == 0 {
+                b" ["
+            } else {
+                b"0,"
+            }
         },
         None,
         Some(ParseOptions::new().progress_callback(callback)),
@@ -845,7 +830,11 @@ fn test_parsing_with_a_timeout() {
     let start_time = time::Instant::now();
     let tree = parser.parse_with_options(
         &mut |offset, _| {
-            if offset == 0 { b" [" } else { b",0" }
+            if offset == 0 {
+                b" ["
+            } else {
+                b",0"
+            }
         },
         None,
         Some(ParseOptions::new().progress_callback(&mut |_| {
@@ -863,7 +852,11 @@ fn test_parsing_with_a_timeout() {
     let start_time = time::Instant::now();
     let tree = parser.parse_with_options(
         &mut |offset, _| {
-            if offset == 0 { b" [" } else { b",0" }
+            if offset == 0 {
+                b" ["
+            } else {
+                b",0"
+            }
         },
         None,
         Some(ParseOptions::new().progress_callback(&mut |_| {
@@ -1060,9 +1053,9 @@ fn test_parsing_with_timeout_during_balancing() {
         let mut parser = Parser::new();
         parser.set_language(&get_language("javascript")).unwrap();
 
-        let function_count: u32 = 100;
+        let function_count = 100;
 
-        let code = "function() {}\n".repeat(function_count as usize);
+        let code = "function() {}\n".repeat(function_count);
         let mut current_byte_offset = 0;
         let mut in_balancing = false;
         let tree = parser.parse_with_options(
@@ -1136,7 +1129,7 @@ fn test_parsing_with_timeout_during_balancing() {
                 Some(ParseOptions::new().progress_callback(&mut |state| {
                     // Because we've already finished parsing, we should only be resuming the
                     // balancing phase.
-                    assert_eq!(state.current_byte_offset(), current_byte_offset);
+                    assert!(state.current_byte_offset() == current_byte_offset);
                     ControlFlow::Continue(())
                 })),
             )
@@ -1804,15 +1797,11 @@ fn test_parsing_with_scanner_logging() {
         .unwrap();
 
     let mut found = false;
-    // SAFETY: the logger borrows `found` and is only invoked during the `parse`
-    // call below, while `found` is in scope.
-    unsafe {
-        parser.set_logger_unchecked(Some(Box::new(|log_type, message| {
-            if log_type == LogType::Lex && message == "Found a percent string" {
-                found = true;
-            }
-        })));
-    }
+    parser.set_logger(Some(Box::new(|log_type, message| {
+        if log_type == LogType::Lex && message == "Found a percent string" {
+            found = true;
+        }
+    })));
 
     let source_code = "x + %(sup (external) scanner?)";
 
@@ -1932,7 +1921,7 @@ fn test_decode_cp1252() {
         fn decode(bytes: &[u8]) -> (i32, u32) {
             if !bytes.is_empty() {
                 let byte = bytes[0];
-                (i32::from(byte), 1)
+                (byte as i32, 1)
             } else {
                 (0, 0)
             }
@@ -1968,7 +1957,7 @@ fn test_decode_macintosh() {
         fn decode(bytes: &[u8]) -> (i32, u32) {
             if !bytes.is_empty() {
                 let byte = bytes[0];
-                (i32::from(byte), 1)
+                (byte as i32, 1)
             } else {
                 (0, 0)
             }
@@ -2030,9 +2019,8 @@ fn test_decode_utf24le() {
 
 #[test]
 fn test_grammars_that_should_not_compile() {
-    assert!(
-        generate_parser(
-            r#"
+    assert!(generate_parser(
+        r#"
         {
             "name": "issue_1111",
             "rules": {
@@ -2040,13 +2028,11 @@ fn test_grammars_that_should_not_compile() {
             },
         }
         "#
-        )
-        .is_err()
-    );
+    )
+    .is_err());
 
-    assert!(
-        generate_parser(
-            r#"
+    assert!(generate_parser(
+        r#"
         {
             "name": "issue_1271",
             "rules": {
@@ -2061,13 +2047,11 @@ fn test_grammars_that_should_not_compile() {
             },
         }
         "#
-        )
-        .is_err()
-    );
+    )
+    .is_err());
 
-    assert!(
-        generate_parser(
-            r#"
+    assert!(generate_parser(
+        r#"
         {
             "name": "issue_1156_expl_1",
             "rules": {
@@ -2081,13 +2065,11 @@ fn test_grammars_that_should_not_compile() {
             },
         }
         "#
-        )
-        .is_err()
-    );
+    )
+    .is_err());
 
-    assert!(
-        generate_parser(
-            r#"
+    assert!(generate_parser(
+        r#"
         {
             "name": "issue_1156_expl_2",
             "rules": {
@@ -2104,13 +2086,11 @@ fn test_grammars_that_should_not_compile() {
             },
         }
         "#
-        )
-        .is_err()
-    );
+    )
+    .is_err());
 
-    assert!(
-        generate_parser(
-            r#"
+    assert!(generate_parser(
+        r#"
         {
             "name": "issue_1156_expl_3",
             "rules": {
@@ -2124,13 +2104,11 @@ fn test_grammars_that_should_not_compile() {
             },
         }
         "#
-        )
-        .is_err()
-    );
+    )
+    .is_err());
 
-    assert!(
-        generate_parser(
-            r#"
+    assert!(generate_parser(
+        r#"
         {
             "name": "issue_1156_expl_4",
             "rules": {
@@ -2147,9 +2125,8 @@ fn test_grammars_that_should_not_compile() {
             },
         }
         "#
-        )
-        .is_err()
-    );
+    )
+    .is_err());
 }
 
 const fn simple_range(start: usize, end: usize) -> Range {

crates/cli/src/tests/proc_macro/Cargo.toml

@@ -14,4 +14,4 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0.93"
 quote = "1.0.38"
-syn = { features = [ "full" ], version = "2.0.96" }
+syn = { version = "2.0.96", features = ["full"] }

crates/cli/src/tests/proc_macro/src/lib.rs

@@ -2,9 +2,8 @@ use proc_macro::TokenStream;
 use proc_macro2::Span;
 use quote::quote;
 use syn::{
-    Error, Expr, Ident, ItemFn, LitInt, Token,
     parse::{Parse, ParseStream},
-    parse_macro_input,
+    parse_macro_input, Error, Expr, Ident, ItemFn, LitInt, Token,
 };
 
 #[proc_macro_attribute]
@@ -69,7 +68,7 @@ pub fn test_with_seed(args: TokenStream, input: TokenStream) -> TokenStream {
                         return Err(Error::new(
                             name.span(),
                             format!("Unsupported parameter `{x}`"),
-                        ));
+                        ))
                     }
                 }
 

crates/cli/src/tests/query_test.rs

@@ -1,12 +1,12 @@
 use std::{env, fmt::Write, ops::ControlFlow, sync::LazyLock};
 
 use indoc::indoc;
-use rand::{SeedableRng, prelude::StdRng};
+use rand::{prelude::StdRng, SeedableRng};
 use streaming_iterator::StreamingIterator;
 use tree_sitter::{
     CaptureQuantifier, InputEdit, Language, Node, Parser, Point, Query, QueryCursor,
-    QueryCursorOptions, QueryCursorState, QueryError, QueryErrorKind, QueryPredicate,
-    QueryPredicateArg, QueryProperty, Range,
+    QueryCursorOptions, QueryError, QueryErrorKind, QueryPredicate, QueryPredicateArg,
+    QueryProperty, Range,
 };
 use tree_sitter_generate::load_grammar_file;
 use unindent::Unindent;
@@ -14,14 +14,15 @@ use unindent::Unindent;
 use super::helpers::{
     allocations,
     fixtures::{get_language, get_test_language},
-    query_helpers::{Match, Pattern, assert_query_matches},
+    query_helpers::{assert_query_matches, Match, Pattern},
 };
 use crate::tests::{
-    ITERATION_COUNT, generate_parser,
+    generate_parser,
     helpers::{
         fixtures::get_test_fixture_language,
         query_helpers::{collect_captures, collect_matches},
     },
+    ITERATION_COUNT,
 };
 
 static EXAMPLE_FILTER: LazyLock<Option<String>> =
@@ -33,13 +34,11 @@ fn test_query_errors_on_invalid_syntax() {
         let language = get_language("javascript");
 
         assert!(Query::new(&language, "(if_statement)").is_ok());
-        assert!(
-            Query::new(
-                &language,
-                "(if_statement condition:(parenthesized_expression (identifier)))"
-            )
-            .is_ok()
-        );
+        assert!(Query::new(
+            &language,
+            "(if_statement condition:(parenthesized_expression (identifier)))"
+        )
+        .is_ok());
 
         // Mismatched parens
         assert_eq!(
@@ -256,51 +255,6 @@ fn test_query_errors_on_invalid_syntax() {
     });
 }
 
-#[test]
-fn test_query_errors_on_anchor_at_group_edge() {
-    allocations::record(|| {
-        let language = get_language("javascript");
-
-        // Anchors between siblings, or at the first/last position of a *node*
-        // pattern, are valid.
-        assert!(Query::new(&language, "((_) . (_))").is_ok());
-        assert!(Query::new(&language, "(program (_) (_) .)").is_ok());
-        assert!(Query::new(&language, "(program (_)* @x . (_))").is_ok());
-
-        // A `.` at the edge of a *group* is rejected. A group is not a node, so it
-        // has no last child to anchor, and there is no sibling within the group to
-        // anchor to.
-        assert_eq!(
-            Query::new(&language, "((_) .)").unwrap_err(),
-            QueryError {
-                row: 0,
-                offset: 5,
-                column: 5,
-                kind: QueryErrorKind::Syntax,
-                message: [
-                    "((_) .)", //
-                    "     ^"
-                ]
-                .join("\n")
-            }
-        );
-        assert_eq!(
-            Query::new(&language, "(program ((_)+ .)? (_))").unwrap_err(),
-            QueryError {
-                row: 0,
-                offset: 15,
-                column: 15,
-                kind: QueryErrorKind::Syntax,
-                message: [
-                    "(program ((_)+ .)? (_))", //
-                    "               ^"
-                ]
-                .join("\n")
-            }
-        );
-    });
-}
-
 #[test]
 fn test_query_errors_on_invalid_symbols() {
     allocations::record(|| {
@@ -416,16 +370,6 @@ fn test_query_errors_on_invalid_symbols() {
                 message: "\"fakefield\"".to_string()
             }
         );
-        assert_eq!(
-            Query::new(&language, "(MISS)").unwrap_err(),
-            QueryError {
-                row: 0,
-                offset: 1,
-                column: 1,
-                kind: QueryErrorKind::NodeType,
-                message: "\"MISS\"".to_string(),
-            }
-        );
     });
 }
 
@@ -1163,8 +1107,8 @@ fn test_query_matches_with_immediate_siblings() {
         //    siblings before that child node.
         // 2. After the last child node in a pattern, it means that there cannot be any named
         //    sibling after that child node.
-        // 3. Between two child nodes in a pattern, it specifies that there cannot be any named
-        //    siblings between those two child nodes.
+        // 2. Between two child nodes in a pattern, it specifies that there cannot be any named
+        //    siblings between those two child snodes.
         let query = Query::new(
             &language,
             "
@@ -1232,209 +1176,6 @@ fn test_query_matches_with_immediate_siblings() {
     });
 }
 
-#[test]
-fn test_query_matches_with_anchor_after_zero_quantifier() {
-    allocations::record(|| {
-        let language = get_language("javascript");
-        let query = Query::new(
-            &language,
-            "(program (comment)* @doc . (function_declaration name: (identifier) @name))",
-        )
-        .unwrap();
-
-        // No comments and the function is not the first child. An anchor after a
-        // zero-matched quantifier is vacuous, so the function still matches.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-class X {}
-function foo() {}
-",
-            &[(0, vec![("name", "foo")])],
-        );
-
-        // With at least one comment the anchor applies, so the comments must
-        // immediately precede the function.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-// c
-function foo() {}
-",
-            &[(0, vec![("doc", "// c"), ("name", "foo")])],
-        );
-    });
-}
-
-#[test]
-fn test_query_matches_with_anchor_after_nested_zero_quantifier() {
-    allocations::record(|| {
-        let language = get_language("javascript");
-        let query = Query::new(
-            &language,
-            r#"
-            (_
-              (field_definition
-                property: (_) @name
-                value: (_)? @value
-              ) @field
-              .
-              ";" @semicolon
-            )
-            "#,
-        )
-        .unwrap();
-
-        assert_query_matches(
-            &language,
-            &query,
-            "class Foo { bar; baz = 0; }",
-            &[
-                (
-                    0,
-                    vec![("field", "bar"), ("name", "bar"), ("semicolon", ";")],
-                ),
-                (
-                    0,
-                    vec![
-                        ("field", "baz = 0"),
-                        ("name", "baz"),
-                        ("value", "0"),
-                        ("semicolon", ";"),
-                    ],
-                ),
-            ],
-        );
-    });
-}
-
-#[test]
-fn test_query_matches_with_last_child_anchor_after_optional() {
-    allocations::record(|| {
-        let language = get_language("c");
-        let query = Query::new(
-            &language,
-            "(preproc_if (preproc_def)+ @def . (preproc_else)? @else .)",
-        )
-        .unwrap();
-
-        // The optional `(preproc_else)?` is absent, so the trailing anchor's
-        // last-child requirement transfers to the last `preproc_def`. A trailing
-        // comment means the def is not the last child, so nothing matches.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-#if X
-#define A
-// c
-#endif
-",
-            &[],
-        );
-
-        // With the def as the last child, the (else-less) match is allowed.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-#if X
-#define A
-#endif
-",
-            &[(0, vec![("def", "#define A\n")])],
-        );
-    });
-}
-
-#[test]
-fn test_query_matches_with_anchors_on_both_sides_of_zero_quantifier() {
-    allocations::record(|| {
-        let language = get_language("javascript");
-        let query = Query::new(
-            &language,
-            "(program (lexical_declaration) @a . (comment)* . (function_declaration) @b)",
-        )
-        .unwrap();
-
-        // Anchors on both sides of a zero-matched quantifier collapse into a single
-        // adjacency constraint: with no comments, the declaration must be immediately
-        // followed by the function.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-const a = 1;
-const b = 2;
-function foo() {}
-",
-            &[(0, vec![("a", "const b = 2;"), ("b", "function foo() {}")])],
-        );
-
-        // With a comment present the quantifier is non-zero, so the anchors apply
-        // normally: the comment must sit immediately between the declaration and the
-        // function.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-const b = 2;
-// c
-function foo() {}
-",
-            &[(0, vec![("a", "const b = 2;"), ("b", "function foo() {}")])],
-        );
-    });
-}
-
-#[test]
-fn test_query_matches_with_leading_anchor_before_zero_quantifier() {
-    allocations::record(|| {
-        let language = get_language("c");
-        let query = Query::new(
-            &language,
-            "(translation_unit . (comment)* (function_definition) @f)",
-        )
-        .unwrap();
-
-        // The leading `.` anchors the comment run to the parent's first child. When the
-        // run matches zero comments, that first-child requirement transfers to the
-        // function, so it matches only when it is itself the first child.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-int main() {}
-",
-            &[(0, vec![("f", "int main() {}")])],
-        );
-
-        // The function is the second child, so with no leading comments it must not match.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-int a;
-int main() {}
-",
-            &[],
-        );
-
-        // With a leading comment the run starts at the first child and the function follows.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-// c
-int main() {}
-",
-            &[(0, vec![("f", "int main() {}")])],
-        );
-    });
-}
-
 #[test]
 fn test_query_matches_with_last_named_child() {
     allocations::record(|| {
@@ -1607,35 +1348,6 @@ fn test_query_matches_with_repeated_leaf_nodes() {
     });
 }
 
-#[test]
-fn test_query_matches_optional_capture_before_uncaptured_required_sibling() {
-    allocations::record(|| {
-        let language = get_language("rust");
-        let query = Query::new(&language, "(block (line_comment)? @doc (line_comment))").unwrap();
-
-        // The optional `(line_comment)? @doc` before an *uncaptured* required
-        // `(line_comment)` yields two candidate completions at the block:
-        //     - one where the optional captured `// a` (the required node is then `// b`),
-        //     - one where the optional matched zero (the required node absorbs `// a`,
-        //     leaving `@doc` unbound).
-        // The zero-match completion's captures are a strict subset of the other's, so the
-        // longest-match rule must drop it (there is exactly one match). This regressed when
-        // the dedup pass gained an early-break. Without the accompanying capture-position
-        // sort, the break skips the subset "loser" and it leaks as an extra empty match.
-        assert_query_matches(
-            &language,
-            &query,
-            "
-            fn f() {
-                // a
-                // b
-            }
-            ",
-            &[(0, vec![("doc", "// a")])],
-        );
-    });
-}
-
 #[test]
 fn test_query_matches_with_optional_nodes_inside_of_repetitions() {
     allocations::record(|| {
@@ -1880,148 +1592,6 @@ fn test_query_matches_with_leading_zero_or_more_repeated_leaf_nodes() {
     });
 }
 
-#[test]
-fn test_matches_with_anchor_sibling_inside_parent() {
-    allocations::record(|| {
-        let language = get_language("rust");
-
-        let query = Query::new(
-            &language,
-            "
-            (source_file
-                (line_comment)
-                .
-                (function_item
-                    name: (identifier) @name)
-            )",
-        )
-        .unwrap();
-
-        assert_query_matches(
-            &language,
-            &query,
-            "
-            // A
-            fn a() {}
-
-            // B
-            fn b() {}
-            ",
-            &[(0, vec![("name", "a")]), (0, vec![("name", "b")])],
-        );
-    });
-}
-
-#[test]
-fn test_matches_with_anchor_sibling_with_quantifier_inside_parent() {
-    allocations::record(|| {
-        let language = get_language("rust");
-
-        let query = Query::new(
-            &language,
-            "
-            (source_file
-                (line_comment)+
-                .
-                (function_item
-                    name: (identifier) @name)
-            )",
-        )
-        .unwrap();
-
-        assert_query_matches(
-            &language,
-            &query,
-            "
-            // A
-            fn a() {}
-
-            // B
-            fn b() {}
-            ",
-            &[(0, vec![("name", "a")]), (0, vec![("name", "b")])],
-        );
-    });
-}
-
-#[test]
-fn test_matches_with_anchor_sibling_with_quantifier_captured_inside_parent() {
-    allocations::record(|| {
-        let language = get_language("rust");
-
-        let query = Query::new(
-            &language,
-            "
-            (source_file
-                (line_comment)+ @doc
-                .
-                (function_item
-                    name: (identifier) @name)
-            )",
-        )
-        .unwrap();
-
-        assert_query_matches(
-            &language,
-            &query,
-            "
-            // A
-            fn a() {}
-
-            // B
-            fn b() {}
-            ",
-            &[
-                (0, vec![("doc", "// A"), ("name", "a")]),
-                (0, vec![("doc", "// B"), ("name", "b")]),
-            ],
-        );
-    });
-}
-
-#[test]
-fn test_matches_anchored_quantified_sibling_inside_parent() {
-    allocations::record(|| {
-        let language = get_language("c");
-        let query = Query::new(
-            &language,
-            "(translation_unit (comment)* @comment . (declaration) @decl)",
-        )
-        .unwrap();
-        assert_query_matches(
-            &language,
-            &query,
-            "
-void foo() {}
-
-// this one has
-// two comments
-extern int baz;
-
-// this one has a comment
-extern int bar;
-",
-            &[
-                (
-                    0,
-                    vec![
-                        ("comment", "// this one has"),
-                        ("comment", "// two comments"),
-                        ("decl", "extern int baz;"),
-                    ],
-                ),
-                (
-                    0,
-                    vec![
-                        ("comment", "// this one has a comment"),
-                        ("decl", "extern int bar;"),
-                    ],
-                ),
-            ],
-        );
-    });
-}
-
 #[test]
 fn test_query_matches_with_trailing_optional_nodes() {
     allocations::record(|| {
@@ -2370,7 +1940,7 @@ fn test_query_matches_with_too_many_permutations_to_track() {
         let matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
 
         // For this pathological query, some match permutations will be dropped.
-        // Just check that a subset of the results are returned, and no crash or
+        // Just check that a subset of the results are returned, and crash or
         // leak occurs.
         assert_eq!(
             collect_matches(matches, &query, source.as_str())[0],
@@ -2597,7 +2167,7 @@ fn test_query_matches_with_supertypes() {
 }
 
 #[test]
-#[expect(clippy::reversed_empty_ranges, reason = "testing empty range behavior")]
+#[allow(clippy::reversed_empty_ranges)]
 fn test_query_matches_within_byte_range() {
     allocations::record(|| {
         let language = get_language("javascript");
@@ -2918,7 +2488,7 @@ fn test_query_matches_with_wildcard_at_root_intersecting_byte_range() {
         );
 
         while let Some(mat) = match_iter.next() {
-            if let Some(capture) = mat.captures().first() {
+            if let Some(capture) = mat.captures.first() {
                 matches.push(capture.node.kind());
             }
         }
@@ -2934,7 +2504,7 @@ fn test_query_matches_with_wildcard_at_root_intersecting_byte_range() {
         );
 
         while let Some(mat) = match_iter.next() {
-            if let Some(capture) = mat.captures().first() {
+            if let Some(capture) = mat.captures.first() {
                 matches.push(capture.node.kind());
             }
         }
@@ -2950,7 +2520,7 @@ fn test_query_matches_with_wildcard_at_root_intersecting_byte_range() {
         );
 
         while let Some(mat) = match_iter.next() {
-            if let Some(capture) = mat.captures().first() {
+            if let Some(capture) = mat.captures.first() {
                 matches.push(capture.node.kind());
             }
         }
@@ -3008,7 +2578,7 @@ fn test_query_captures_within_byte_range_assigned_after_iterating() {
         let mut results = Vec::new();
         let mut first_five = captures.by_ref().take(5);
         while let Some((mat, capture_ix)) = first_five.next() {
-            let capture = mat.captures()[*capture_ix];
+            let capture = mat.captures[*capture_ix];
             results.push((
                 query.capture_names()[capture.index as usize],
                 &source[capture.node.byte_range()],
@@ -3031,7 +2601,7 @@ fn test_query_captures_within_byte_range_assigned_after_iterating() {
         results.clear();
         captures.set_byte_range(source.find("Ok").unwrap()..source.len());
         while let Some((mat, capture_ix)) = captures.next() {
-            let capture = mat.captures()[*capture_ix];
+            let capture = mat.captures[*capture_ix];
             results.push((
                 query.capture_names()[capture.index as usize],
                 &source[capture.node.byte_range()],
@@ -3330,7 +2900,7 @@ fn test_query_matches_with_captured_wildcard_at_root() {
 
         while let Some(m) = match_iter.next() {
             let captures = m
-                .captures()
+                .captures
                 .iter()
                 .map(|c| {
                     (
@@ -4311,7 +3881,7 @@ fn test_query_captures_with_matches_removed() {
 
         let mut captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
         while let Some((m, i)) = captures.next() {
-            let capture = m.captures()[*i];
+            let capture = m.captures[*i];
             let text = capture.node.utf8_text(source.as_bytes()).unwrap();
             if text == "a" {
                 m.remove();
@@ -4356,7 +3926,7 @@ fn test_query_captures_with_matches_removed_before_they_finish() {
         let mut captured_strings = Vec::new();
         let mut captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
         while let Some((m, i)) = captures.next() {
-            let capture = m.captures()[*i];
+            let capture = m.captures[*i];
             let text = capture.node.utf8_text(source.as_bytes()).unwrap();
             if text == "as" {
                 m.remove();
@@ -4397,18 +3967,18 @@ fn test_query_captures_and_matches_iterators_are_fused() {
         let mut cursor = QueryCursor::new();
         let mut captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
 
-        assert_eq!(captures.next().unwrap().0.captures()[0].index, 0);
-        assert_eq!(captures.next().unwrap().0.captures()[0].index, 0);
-        assert_eq!(captures.next().unwrap().0.captures()[0].index, 0);
+        assert_eq!(captures.next().unwrap().0.captures[0].index, 0);
+        assert_eq!(captures.next().unwrap().0.captures[0].index, 0);
+        assert_eq!(captures.next().unwrap().0.captures[0].index, 0);
         assert!(captures.next().is_none());
         assert!(captures.next().is_none());
         assert!(captures.next().is_none());
         drop(captures);
 
         let mut matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
-        assert_eq!(matches.next().unwrap().captures()[0].index, 0);
-        assert_eq!(matches.next().unwrap().captures()[0].index, 0);
-        assert_eq!(matches.next().unwrap().captures()[0].index, 0);
+        assert_eq!(matches.next().unwrap().captures[0].index, 0);
+        assert_eq!(matches.next().unwrap().captures[0].index, 0);
+        assert_eq!(matches.next().unwrap().captures[0].index, 0);
         assert!(matches.next().is_none());
         assert!(matches.next().is_none());
         assert!(matches.next().is_none());
@@ -4583,13 +4153,13 @@ fn test_query_lifetime_is_separate_from_nodes_lifetime() {
             let language = get_language("javascript");
             let query = Query::new(&language, query).unwrap();
             let mut cursor = QueryCursor::new();
-
-            cursor
+            let node = cursor
                 .matches(&query, node, source.as_bytes())
                 .next()
                 .unwrap()
-                .captures()[0]
-                .node
+                .captures[0]
+                .node;
+            node
         }
 
         let node = take_first_node_from_captures(source, query, tree.root_node());
@@ -4603,14 +4173,14 @@ fn test_query_lifetime_is_separate_from_nodes_lifetime() {
             let language = get_language("javascript");
             let query = Query::new(&language, query).unwrap();
             let mut cursor = QueryCursor::new();
-
-            cursor
+            let node = cursor
                 .captures(&query, node, source.as_bytes())
                 .next()
                 .unwrap()
                 .0
-                .captures()[0]
-                .node
+                .captures[0]
+                .node;
+            node
         }
 
         let node = take_first_node_from_matches(source, query, tree.root_node());
@@ -4623,7 +4193,7 @@ fn test_query_with_no_patterns() {
     allocations::record(|| {
         let language = get_language("javascript");
         let query = Query::new(&language, "").unwrap();
-        assert_eq!(query.capture_names(), [] as [&str; 0]);
+        assert!(query.capture_names().is_empty());
         assert_eq!(query.pattern_count(), 0);
     });
 }
@@ -4696,54 +4266,6 @@ fn test_query_disable_pattern() {
     });
 }
 
-#[test]
-fn test_query_deep_clone() {
-    allocations::record(|| {
-        let language = get_language("javascript");
-        let query = Query::new(
-            &language,
-            "
-                (function_declaration
-                    name: (identifier) @name)
-                (function_declaration
-                    body: (statement_block) @body)
-            ",
-        )
-        .unwrap();
-
-        let mut clone = query.deep_clone();
-        clone.disable_pattern(1);
-
-        let source = "function foo() { return 1; }";
-        let mut parser = Parser::new();
-        parser.set_language(&language).unwrap();
-        let tree = parser.parse(source, None).unwrap();
-        let mut cursor = QueryCursor::new();
-
-        // The clone with pattern 1 disabled only produces the @name match.
-        let clone_matches = collect_matches(
-            cursor.matches(&clone, tree.root_node(), source.as_bytes()),
-            &clone,
-            source,
-        );
-        assert_eq!(clone_matches, &[(0, vec![("name", "foo")])]);
-
-        // The original is unaffected and still produces both @name and @body.
-        let original_matches = collect_matches(
-            cursor.matches(&query, tree.root_node(), source.as_bytes()),
-            &query,
-            source,
-        );
-        assert_eq!(
-            original_matches,
-            &[
-                (0, vec![("name", "foo")]),
-                (1, vec![("body", "{ return 1; }")]),
-            ]
-        );
-    });
-}
-
 #[test]
 fn test_query_alternative_predicate_prefix() {
     allocations::record(|| {
@@ -4819,7 +4341,7 @@ fn test_query_random() {
                 let transformed_match = Match {
                     last_node: None,
                     captures: mat
-                        .captures()
+                        .captures
                         .iter()
                         .map(|c| (query.capture_names()[c.index as usize], c.node))
                         .collect::<Vec<_>>(),
@@ -5122,10 +4644,10 @@ fn test_query_is_pattern_guaranteed_at_step() {
         eprintln!();
 
         for row in rows {
-            if let Some(filter) = EXAMPLE_FILTER.as_ref()
-                && !row.description.contains(filter.as_str())
-            {
-                continue;
+            if let Some(filter) = EXAMPLE_FILTER.as_ref() {
+                if !row.description.contains(filter.as_str()) {
+                    continue;
+                }
             }
             eprintln!("  query example: {:?}", row.description);
             let query = Query::new(&row.language, row.pattern).unwrap();
@@ -5218,10 +4740,10 @@ fn test_query_is_pattern_rooted() {
 
         let language = get_language("python");
         for row in &rows {
-            if let Some(filter) = EXAMPLE_FILTER.as_ref()
-                && !row.description.contains(filter.as_str())
-            {
-                continue;
+            if let Some(filter) = EXAMPLE_FILTER.as_ref() {
+                if !row.description.contains(filter.as_str()) {
+                    continue;
+                }
             }
             eprintln!("  query example: {:?}", row.description);
             let query = Query::new(&language, row.pattern).unwrap();
@@ -5315,10 +4837,10 @@ fn test_query_is_pattern_non_local() {
         eprintln!();
 
         for row in &rows {
-            if let Some(filter) = EXAMPLE_FILTER.as_ref()
-                && !row.description.contains(filter.as_str())
-            {
-                continue;
+            if let Some(filter) = EXAMPLE_FILTER.as_ref() {
+                if !row.description.contains(filter.as_str()) {
+                    continue;
+                }
             }
             eprintln!("  query example: {:?}", row.description);
             let query = Query::new(&row.language, row.pattern).unwrap();
@@ -5545,10 +5067,10 @@ fn test_capture_quantifiers() {
         eprintln!();
 
         for row in rows {
-            if let Some(filter) = EXAMPLE_FILTER.as_ref()
-                && !row.description.contains(filter.as_str())
-            {
-                continue;
+            if let Some(filter) = EXAMPLE_FILTER.as_ref() {
+                if !row.description.contains(filter.as_str()) {
+                    continue;
+                }
             }
             eprintln!("  query example: {:?}", row.description);
             let query = Query::new(&row.language, row.pattern).unwrap();
@@ -5833,10 +5355,10 @@ fn test_consecutive_zero_or_modifiers() {
         let mut len_1 = false;
 
         while let Some(m) = matches.next() {
-            if m.captures().len() == 3 {
+            if m.captures.len() == 3 {
                 len_3 = true;
             }
-            if m.captures().len() == 1 {
+            if m.captures.len() == 1 {
                 len_1 = true;
             }
         }
@@ -5898,7 +5420,7 @@ fn test_query_max_start_depth_more() {
         let query = Query::new(&language, "(compound_statement) @capture").unwrap();
 
         let mut matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
-        let node = matches.next().unwrap().captures()[0].node;
+        let node = matches.next().unwrap().captures[0].node;
         assert_eq!(node.kind(), "compound_statement");
 
         for row in rows {
@@ -6074,21 +5596,21 @@ fn test_query_execution_with_timeout() {
     let tree = parser.parse(&source_code, None).unwrap();
 
     let query = Query::new(&language, "(function_declaration) @function").unwrap();
-    let start_time = std::time::Instant::now();
-    let mut progress_callback = |_: &QueryCursorState| {
-        if start_time.elapsed().as_micros() > 1000 {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    };
     let mut cursor = QueryCursor::new();
+
+    let start_time = std::time::Instant::now();
     let matches = cursor
         .matches_with_options(
             &query,
             tree.root_node(),
             source_code.as_bytes(),
-            QueryCursorOptions::new().progress_callback(&mut progress_callback),
+            QueryCursorOptions::new().progress_callback(&mut |_| {
+                if start_time.elapsed().as_micros() > 1000 {
+                    ControlFlow::Break(())
+                } else {
+                    ControlFlow::Continue(())
+                }
+            }),
         )
         .count();
     assert!(matches < 1000);
@@ -6099,43 +5621,13 @@ fn test_query_execution_with_timeout() {
     assert_eq!(matches, 1000);
 }
 
-#[test]
-fn test_query_progress_callback_lives_as_long_as_matches() {
-    let language = get_language("javascript");
-    let mut parser = Parser::new();
-    parser.set_language(&language).unwrap();
-
-    let source_code = "function foo() {}\n".repeat(1000);
-    let tree = parser.parse(&source_code, None).unwrap();
-    let query = Query::new(&language, "(function_declaration) @function").unwrap();
-
-    let mut cursor = QueryCursor::new();
-    let mut callback_was_called = false;
-    let mut progress_callback = |_: &QueryCursorState| {
-        callback_was_called = true;
-        ControlFlow::Continue(())
-    };
-    let matches = cursor.matches_with_options(
-        &query,
-        tree.root_node(),
-        source_code.as_bytes(),
-        QueryCursorOptions::new().progress_callback(&mut progress_callback),
-    );
-
-    assert_eq!(matches.count(), 1000);
-    assert!(callback_was_called);
-}
-
 #[test]
 fn test_query_execution_with_points_causing_underflow() {
     let language = get_language("rust");
     let mut parser = Parser::new();
     parser.set_language(&language).unwrap();
 
-    #[expect(
-        clippy::literal_string_with_formatting_args,
-        reason = "raw string contains format syntax as literal code"
-    )]
+    #[allow(clippy::literal_string_with_formatting_args)]
     let code = r#"fn main() {
     println!("{:?}", foo());
 }"#;
@@ -6537,64 +6029,3 @@ export default grammar({
 
     assert_query_matches(&language, &query, source, &[(0, vec![("tuple", "()")])]);
 }
-
-#[test]
-fn test_last_child_anchor_looks_past_hidden_repeat() {
-    let language = get_test_fixture_language("last_child_anchor_past_hidden_repeat");
-
-    let source = "T a.b.c\nL a.b.c\nN a!.b!.c\n";
-
-    let query = Query::new(
-        &language,
-        "
-        (trailing_sep (name) @last .)
-        (leading_sep (name) @last .)
-        (trailing_named (name) @last .)
-        ",
-    )
-    .unwrap();
-
-    assert_query_matches(
-        &language,
-        &query,
-        source,
-        &[
-            (0, vec![("last", "c")]),
-            (1, vec![("last", "c")]),
-            (2, vec![("last", "c")]),
-        ],
-    );
-
-    let query = Query::new(
-        &language,
-        "
-        (trailing_sep . (name) @first)
-        (trailing_sep (name) @a . (name) @b)
-        ",
-    )
-    .unwrap();
-
-    assert_query_matches(
-        &language,
-        &query,
-        source,
-        &[
-            (0, vec![("first", "a")]),
-            (1, vec![("a", "a"), ("b", "b")]),
-            (1, vec![("a", "b"), ("b", "c")]),
-        ],
-    );
-}
-
-#[test]
-fn test_last_child_anchor_looks_past_hidden_node() {
-    allocations::record(|| {
-        let language = get_language("c");
-
-        let query = Query::new(&language, "(translation_unit (_) @last .)").unwrap();
-
-        let source = "enum E { A };\nint x;\nint y;\n";
-
-        assert_query_matches(&language, &query, source, &[(0, vec![("last", "int y;")])]);
-    });
-}

crates/cli/src/tests/tags_test.rs

@@ -1,11 +1,11 @@
 use std::{
     ffi::{CStr, CString},
-    fs, ptr, slice,
+    fs, ptr, slice, str,
     sync::atomic::{AtomicUsize, Ordering},
 };
 
 use tree_sitter::Point;
-use tree_sitter_tags::{Error, TagsConfiguration, TagsContext, c_lib as c};
+use tree_sitter_tags::{c_lib as c, Error, TagsConfiguration, TagsContext};
 
 use super::helpers::{
     allocations,

crates/cli/src/tests/test_highlight_test.rs

@@ -3,8 +3,8 @@ use tree_sitter_highlight::{Highlight, Highlighter};
 
 use super::helpers::fixtures::{get_highlight_config, get_language, test_loader};
 use crate::{
-    query_testing::{Assertion, Utf8Point, parse_position_comments},
-    test_highlight::{Failure, get_highlight_positions, iterate_assertions},
+    query_testing::{parse_position_comments, Assertion, Utf8Point},
+    test_highlight::get_highlight_positions,
 };
 
 #[test]
@@ -68,195 +68,3 @@ fn test_highlight_test_with_basic_test() {
         ]
     );
 }
-
-#[test]
-fn test_assertion_with_non_matching_highlight_at_same_position() {
-    // Test that an assertion fails when the highlight at the position does not match
-    let highlight_names = vec!["keyword".to_string(), "variable".to_string()];
-    let assertions = vec![Assertion::new(1, 0, 1, false, String::from("keyword"))];
-    let highlights = vec![
-        (Utf8Point::new(1, 0), Utf8Point::new(1, 5), Highlight(1)), // "variable" highlight
-    ];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_err());
-    let err = result.unwrap_err().downcast::<Failure>().unwrap();
-    assert_eq!(err.row, 1);
-    assert_eq!(err.column, 0);
-    assert_eq!(err.expected_highlight, "keyword");
-    assert_eq!(err.actual_highlights, vec!["variable".to_string()]);
-}
-
-#[test]
-fn test_assertion_with_exact_matching_highlight() {
-    // Test exact match: assertion and highlight have same start and end
-    let highlight_names = vec!["keyword".to_string()];
-    let assertions = vec![Assertion::new(0, 5, 3, false, String::from("keyword"))];
-    let highlights = vec![(Utf8Point::new(0, 5), Utf8Point::new(0, 8), Highlight(0))];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap(), 1);
-}
-
-#[test]
-fn test_assertion_contained_within_highlight() {
-    // Test where assertion is fully contained within a larger highlight
-    let highlight_names = vec!["keyword".to_string()];
-    let assertions = vec![Assertion::new(0, 3, 2, false, String::from("keyword"))];
-    let highlights = vec![(Utf8Point::new(0, 0), Utf8Point::new(0, 10), Highlight(0))];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap(), 1);
-}
-
-#[test]
-fn test_assertion_overlapping_highlight_start() {
-    // Test where assertion starts before highlight but overlaps with it
-    let highlight_names = vec!["keyword".to_string()];
-    let assertions = vec![Assertion::new(0, 3, 4, false, String::from("keyword"))];
-    let highlights = vec![(Utf8Point::new(0, 5), Utf8Point::new(0, 10), Highlight(0))];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap(), 1);
-}
-
-#[test]
-fn test_assertion_with_no_highlights() {
-    // Test that an assertion fails when there are no highlights at all
-    let highlight_names = vec!["keyword".to_string()];
-    let assertions = vec![Assertion::new(0, 0, 1, false, String::from("keyword"))];
-    let highlights = vec![];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_err());
-    let err = result.unwrap_err().downcast::<Failure>().unwrap();
-    assert_eq!(err.row, 0);
-    assert_eq!(err.column, 0);
-    assert_eq!(err.expected_highlight, "keyword");
-    assert_eq!(err.actual_highlights, Vec::<String>::new());
-}
-
-#[test]
-fn test_assertion_with_highlight_ending_before() {
-    // Test where highlight ends before the assertion starts
-    let highlight_names = vec!["keyword".to_string()];
-    let assertions = vec![Assertion::new(0, 10, 1, false, String::from("keyword"))];
-    let highlights = vec![(Utf8Point::new(0, 0), Utf8Point::new(0, 5), Highlight(0))];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_err());
-    let err = result.unwrap_err().downcast::<Failure>().unwrap();
-    assert_eq!(err.row, 0);
-    assert_eq!(err.column, 10);
-    assert_eq!(err.expected_highlight, "keyword");
-    assert_eq!(err.actual_highlights, Vec::<String>::new());
-}
-
-#[test]
-fn test_negative_assertion_with_non_matching_highlight() {
-    // Test that a negative assertion passes when the specified highlight is NOT present
-    let highlight_names = vec!["keyword".to_string(), "variable".to_string()];
-    let assertions = vec![Assertion::new(0, 0, 1, true, String::from("keyword"))];
-    let highlights = vec![
-        (Utf8Point::new(0, 0), Utf8Point::new(0, 5), Highlight(1)), // "variable" highlight
-    ];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap(), 1);
-}
-
-#[test]
-fn test_negative_assertion_with_matching_highlight() {
-    // Test that a negative assertion fails when the specified highlight IS present
-    let highlight_names = vec!["keyword".to_string()];
-    let assertions = vec![Assertion::new(0, 0, 1, true, String::from("keyword"))];
-    let highlights = vec![
-        (Utf8Point::new(0, 0), Utf8Point::new(0, 5), Highlight(0)), // "keyword" highlight
-    ];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_err());
-    let err = result.unwrap_err().downcast::<Failure>().unwrap();
-    assert_eq!(err.row, 0);
-    assert_eq!(err.column, 0);
-    assert_eq!(err.expected_highlight, "!keyword");
-    assert_eq!(err.actual_highlights, vec!["keyword".to_string()]);
-}
-
-#[test]
-fn test_multiple_assertions_sequential() {
-    // Test multiple assertions in sequence with non-overlapping highlights
-    let highlight_names = vec!["keyword".to_string(), "variable".to_string()];
-    let assertions = vec![
-        Assertion::new(0, 0, 3, false, String::from("keyword")),
-        Assertion::new(0, 10, 1, false, String::from("variable")),
-    ];
-    let highlights = vec![
-        (Utf8Point::new(0, 0), Utf8Point::new(0, 3), Highlight(0)), // "keyword"
-        (Utf8Point::new(0, 10), Utf8Point::new(0, 11), Highlight(1)), // "variable"
-    ];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap(), 2);
-}
-
-#[test]
-fn test_multiple_highlights_at_same_position() {
-    // Test where multiple highlights overlap at the assertion position
-    let highlight_names = vec![
-        "keyword".to_string(),
-        "variable".to_string(),
-        "function".to_string(),
-    ];
-    let assertions = vec![Assertion::new(0, 5, 1, false, String::from("variable"))];
-    let highlights = vec![
-        (Utf8Point::new(0, 0), Utf8Point::new(0, 10), Highlight(0)), // "keyword" spans entire range
-        (Utf8Point::new(0, 5), Utf8Point::new(0, 8), Highlight(1)), // "variable" at assertion position
-        (Utf8Point::new(0, 7), Utf8Point::new(0, 12), Highlight(2)), // "function" overlaps
-    ];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap(), 1);
-}
-
-#[test]
-fn test_assertions_across_multiple_rows() {
-    // Test assertions on different rows
-    let highlight_names = vec!["keyword".to_string(), "variable".to_string()];
-    let assertions = vec![
-        Assertion::new(0, 5, 3, false, String::from("keyword")),
-        Assertion::new(2, 10, 1, false, String::from("variable")),
-    ];
-    let highlights = vec![
-        (Utf8Point::new(0, 5), Utf8Point::new(0, 8), Highlight(0)), // "keyword" on row 0
-        (Utf8Point::new(2, 10), Utf8Point::new(2, 11), Highlight(1)), // "variable" on row 2
-    ];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap(), 2);
-}
-
-#[test]
-fn test_assertion_should_not_match_highlight_on_later_row() {
-    // Test logic for early exit when highlight is on a later row than the assertion
-    let highlight_names = vec!["keyword".to_string()];
-    let assertions = vec![Assertion::new(0, 5, 3, false, String::from("keyword"))];
-    let highlights = vec![
-        (Utf8Point::new(1, 0), Utf8Point::new(1, 5), Highlight(0)), // wrong row
-    ];
-    let result = iterate_assertions(&assertions, &highlights, &highlight_names);
-
-    assert!(result.is_err());
-    let err = result.unwrap_err().downcast::<Failure>().unwrap();
-    assert_eq!(err.row, 0);
-    assert_eq!(err.column, 7); // end_column
-    assert_eq!(err.expected_highlight, "keyword");
-    assert_eq!(err.actual_highlights, Vec::<String>::new());
-}

crates/cli/src/tests/test_tags_test.rs

@@ -3,7 +3,7 @@ use tree_sitter_tags::TagsContext;
 
 use super::helpers::fixtures::{get_language, get_tags_config};
 use crate::{
-    query_testing::{Assertion, Utf8Point, parse_position_comments},
+    query_testing::{parse_position_comments, Assertion, Utf8Point},
     test_tags::get_tag_positions,
 };
 

crates/cli/src/tests/text_provider_test.rs

@@ -30,7 +30,7 @@ fn tree_query<I: AsRef<[u8]>>(tree: &Tree, text: impl TextProvider<I>, language:
     let mut cursor = QueryCursor::new();
     let mut captures = cursor.captures(&query, tree.root_node(), text);
     let (match_, idx) = captures.next().unwrap();
-    let capture = match_.captures()[*idx];
+    let capture = match_.captures[*idx];
     assert_eq!(capture.index as usize, *idx);
     assert_eq!("comment", capture.node.kind());
 }
@@ -126,11 +126,9 @@ fn test_text_provider_callback_with_str_slice() {
     check_parsing(text, |_node: Node<'_>| iter::once(text));
     check_parsing_callback(
         &mut |offset, _point| {
-            if offset < text.len() {
-                text.as_bytes()
-            } else {
-                Default::default()
-            }
+            (offset < text.len())
+                .then_some(text.as_bytes())
+                .unwrap_or_default()
         },
         |_node: Node<'_>| iter::once(text),
     );
@@ -142,11 +140,9 @@ fn test_text_provider_callback_with_owned_string_slice() {
 
     check_parsing_callback(
         &mut |offset, _point| {
-            if offset < text.len() {
-                text.as_bytes()
-            } else {
-                Default::default()
-            }
+            (offset < text.len())
+                .then_some(text.as_bytes())
+                .unwrap_or_default()
         },
         |_node: Node<'_>| {
             let slice: String = text.to_owned();
@@ -161,11 +157,9 @@ fn test_text_provider_callback_with_owned_bytes_vec_slice() {
 
     check_parsing_callback(
         &mut |offset, _point| {
-            if offset < text.len() {
-                text.as_bytes()
-            } else {
-                Default::default()
-            }
+            (offset < text.len())
+                .then_some(text.as_bytes())
+                .unwrap_or_default()
         },
         |_node: Node<'_>| {
             let slice = text.to_owned().into_bytes();
@@ -180,11 +174,9 @@ fn test_text_provider_callback_with_owned_arc_of_bytes_slice() {
 
     check_parsing_callback(
         &mut |offset, _point| {
-            if offset < text.len() {
-                text.as_bytes()
-            } else {
-                Default::default()
-            }
+            (offset < text.len())
+                .then_some(text.as_bytes())
+                .unwrap_or_default()
         },
         |_node: Node<'_>| {
             let slice: Arc<[u8]> = text.to_owned().into_bytes().into();

crates/cli/src/tests/tree_test.rs

@@ -1,3 +1,5 @@
+use std::str;
+
 use tree_sitter::{InputEdit, Parser, Point, Range, Tree};
 
 use super::helpers::fixtures::get_language;
@@ -793,44 +795,3 @@ fn get_changed_ranges(
     *tree = new_tree;
     result
 }
-
-// Regression test for an incremental reparse bug where an external
-// scanner's choice depends on lexer->eof() (and thus on the parser's
-// current included ranges). The cached token at byte 0 was emitted when
-// the included range stopped just after the opener. Widening the range
-// to include a later matching delimiter must invalidate that cached
-// token so the scanner re-runs and emits the open form instead of the
-// unclosed form.
-#[test]
-fn test_reuse_invalidates_scanner_token_when_included_range_expands() {
-    let language = get_test_fixture_language("external_lookahead_eof_boundary");
-    let mut parser = Parser::new();
-    parser.set_language(&language).unwrap();
-
-    let source = "``";
-
-    parser
-        .set_included_ranges(&[Range {
-            start_byte: 0,
-            end_byte: 1,
-            start_point: Point::new(0, 0),
-            end_point: Point::new(0, 1),
-        }])
-        .unwrap();
-    let tree1 = parser.parse(source, None).unwrap();
-    assert_eq!(tree1.root_node().to_sexp(), "(document (unclosed_delim))");
-
-    parser
-        .set_included_ranges(&[Range {
-            start_byte: 0,
-            end_byte: 2,
-            start_point: Point::new(0, 0),
-            end_point: Point::new(0, 2),
-        }])
-        .unwrap();
-    let tree2 = parser.parse(source, Some(&tree1)).unwrap();
-    assert_eq!(
-        tree2.root_node().to_sexp(),
-        "(document (span (open_delim) (close_delim)))"
-    );
-}

crates/cli/src/tests/wasm_language_test.rs

@@ -5,7 +5,7 @@ use tree_sitter::{Parser, Query, QueryCursor, WasmError, WasmErrorKind, WasmStor
 
 use crate::tests::helpers::{
     allocations,
-    fixtures::{ENGINE, WASM_DIR, get_test_fixture_language_wasm},
+    fixtures::{get_test_fixture_language_wasm, ENGINE, WASM_DIR},
 };
 
 #[test]
@@ -73,10 +73,7 @@ fn test_load_wasm_rust_language() {
         parser.set_wasm_store(store).unwrap();
         parser.set_language(&language).unwrap();
         let tree = parser.parse("fn main() {}", None).unwrap();
-        assert_eq!(
-            tree.root_node().to_sexp(),
-            "(source_file (function_item name: (identifier) parameters: (parameters) body: (block)))"
-        );
+        assert_eq!(tree.root_node().to_sexp(), "(source_file (function_item name: (identifier) parameters: (parameters) body: (block)))");
     });
 }
 
@@ -90,10 +87,7 @@ fn test_load_wasm_javascript_language() {
         parser.set_wasm_store(store).unwrap();
         parser.set_language(&language).unwrap();
         let tree = parser.parse("const a = b\nconst c = d", None).unwrap();
-        assert_eq!(
-            tree.root_node().to_sexp(),
-            "(program (lexical_declaration (variable_declarator name: (identifier) value: (identifier))) (lexical_declaration (variable_declarator name: (identifier) value: (identifier))))"
-        );
+        assert_eq!(tree.root_node().to_sexp(), "(program (lexical_declaration (variable_declarator name: (identifier) value: (identifier))) (lexical_declaration (variable_declarator name: (identifier) value: (identifier))))");
     });
 }
 
@@ -107,10 +101,7 @@ fn test_load_wasm_python_language() {
         parser.set_wasm_store(store).unwrap();
         parser.set_language(&language).unwrap();
         let tree = parser.parse("a = b\nc = d", None).unwrap();
-        assert_eq!(
-            tree.root_node().to_sexp(),
-            "(module (expression_statement (assignment left: (identifier) right: (identifier))) (expression_statement (assignment left: (identifier) right: (identifier))))"
-        );
+        assert_eq!(tree.root_node().to_sexp(), "(module (expression_statement (assignment left: (identifier) right: (identifier))) (expression_statement (assignment left: (identifier) right: (identifier))))");
     });
 }
 
@@ -267,18 +258,12 @@ fn test_reset_wasm_store() {
         parser.set_wasm_store(parser_store).unwrap();
         parser.set_language(&language).unwrap();
         let tree = parser.parse("fn main() {}", None).unwrap();
-        assert_eq!(
-            tree.root_node().to_sexp(),
-            "(source_file (function_item name: (identifier) parameters: (parameters) body: (block)))"
-        );
+        assert_eq!(tree.root_node().to_sexp(), "(source_file (function_item name: (identifier) parameters: (parameters) body: (block)))");
 
         let parser_store = WasmStore::new(&ENGINE).unwrap();
         parser.set_wasm_store(parser_store).unwrap();
         let tree = parser.parse("fn main() {}", None).unwrap();
-        assert_eq!(
-            tree.root_node().to_sexp(),
-            "(source_file (function_item name: (identifier) parameters: (parameters) body: (block)))"
-        );
+        assert_eq!(tree.root_node().to_sexp(), "(source_file (function_item name: (identifier) parameters: (parameters) body: (block)))");
     });
 }
 
@@ -387,18 +372,3 @@ fn test_wasm_oom() {
         );
     });
 }
-
-#[test]
-fn test_lookahead_iterator_outlives_wasm_language() {
-    allocations::record(|| {
-        let mut store = WasmStore::new(&ENGINE).unwrap();
-        let wasm = fs::read(WASM_DIR.join("tree-sitter-ruby.wasm")).unwrap();
-        let language = store.load_language("ruby", &wasm).unwrap();
-
-        let mut lookahead = language.lookahead_iterator(0).unwrap();
-        drop(language);
-
-        // The iterator retains the language, so the names are still live.
-        assert!(lookahead.iter_names().count() > 0);
-    });
-}

crates/cli/src/tree_sitter_cli.rs

@@ -5,7 +5,6 @@ pub mod highlight;
 pub mod init;
 pub mod input;
 pub mod logger;
-pub mod paint;
 pub mod parse;
 pub mod playground;
 pub mod query;

crates/cli/src/util.rs

@@ -2,12 +2,12 @@ use std::{
     path::{Path, PathBuf},
     process::{Child, ChildStdin, Command, Stdio},
     sync::{
-        Arc,
         atomic::{AtomicUsize, Ordering},
+        Arc,
     },
 };
 
-use anyhow::{Context, Result, anyhow};
+use anyhow::{anyhow, Context, Result};
 use indoc::indoc;
 use log::error;
 use tree_sitter::{Parser, Tree};
@@ -71,8 +71,8 @@ pub struct LogSession {
     open_log: bool,
 }
 
-pub fn print_tree_graph(tree: &Tree, path: &str, open_log: bool) -> Result<()> {
-    let session = LogSession::new(path, open_log)?;
+pub fn print_tree_graph(tree: &Tree, path: &str, quiet: bool) -> Result<()> {
+    let session = LogSession::new(path, quiet)?;
     tree.print_dot_graph(session.dot_process_stdin.as_ref().unwrap());
     Ok(())
 }
@@ -94,9 +94,9 @@ impl LogSession {
             .stdin(Stdio::piped())
             .stdout(dot_file)
             .spawn()
-            .with_context(
-                || "Failed to run the `dot` command. Check that graphviz is installed.",
-            )?;
+            .with_context(|| {
+                "Failed to run the `dot` command. Check that graphviz is installed."
+            })?;
         let dot_stdin = dot_process
             .stdin
             .take()

crates/cli/src/version.rs

@@ -144,7 +144,7 @@ impl Version {
         }
     }
 
-    fn update_file_with<F>(path: &PathBuf, update_fn: F) -> Result<(), UpdateError>
+    fn update_file_with<F>(&self, path: &PathBuf, update_fn: F) -> Result<(), UpdateError>
     where
         F: Fn(&str) -> String,
     {
@@ -155,7 +155,7 @@ impl Version {
 
     fn update_treesitter_json(&self) -> Result<(), UpdateError> {
         let json_path = self.current_dir.join("tree-sitter.json");
-        Self::update_file_with(&json_path, |content| {
+        self.update_file_with(&json_path, |content| {
             content
                 .lines()
                 .map(|line| {
@@ -189,7 +189,7 @@ impl Version {
             return Ok(());
         }
 
-        Self::update_file_with(&cargo_toml_path, |content| {
+        self.update_file_with(&cargo_toml_path, |content| {
             content
                 .lines()
                 .map(|line| {
@@ -236,7 +236,7 @@ impl Version {
             return Ok(());
         }
 
-        Self::update_file_with(&package_json_path, |content| {
+        self.update_file_with(&package_json_path, |content| {
             content
                 .lines()
                 .map(|line| {
@@ -296,7 +296,7 @@ impl Version {
             return Ok(());
         }
 
-        Self::update_file_with(&makefile_path, |content| {
+        self.update_file_with(&makefile_path, |content| {
             content
                 .lines()
                 .map(|line| {
@@ -320,7 +320,7 @@ impl Version {
             return Ok(());
         }
 
-        Self::update_file_with(&cmake_lists_path, |content| {
+        self.update_file_with(&cmake_lists_path, |content| {
             let re = Regex::new(r#"(\s*VERSION\s+)"[0-9]+\.[0-9]+\.[0-9]+""#)
                 .expect("Failed to compile regex");
             re.replace(
@@ -339,7 +339,7 @@ impl Version {
             return Ok(());
         }
 
-        Self::update_file_with(&pyproject_toml_path, |content| {
+        self.update_file_with(&pyproject_toml_path, |content| {
             content
                 .lines()
                 .map(|line| {
@@ -363,7 +363,7 @@ impl Version {
             return Ok(());
         }
 
-        Self::update_file_with(&zig_zon_path, |content| {
+        self.update_file_with(&zig_zon_path, |content| {
             let zig_version_prefix = ".version =";
             content
                 .lines()

crates/cli/src/wasm.rs

@@ -3,7 +3,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use anyhow::{Context, Result, anyhow};
+use anyhow::{anyhow, Context, Result};
 use tree_sitter::wasm_stdlib_symbols;
 use tree_sitter_generate::{load_grammar_file, parse_grammar::GrammarJSON};
 use tree_sitter_loader::Loader;
@@ -83,17 +83,14 @@ pub fn compile_language_to_wasm(
     let wasm_bytes = fs::read(&output_filename)?;
     let parser = Parser::new(0);
     for payload in parser.parse_all(&wasm_bytes) {
-        if let wasmparser::Payload::ImportSection(reader) = payload? {
-            for imports in reader {
-                for import in imports? {
-                    let (_, import) = import?;
-                    let name = import.name;
-                    if !builtin_symbols.contains(&name)
-                        && !stdlib_symbols.contains(&name)
-                        && !dylink_symbols.contains(&name)
-                    {
-                        missing_symbols.push(name);
-                    }
+        if let wasmparser::Payload::ImportSection(imports) = payload? {
+            for import in imports {
+                let import = import?.name;
+                if !builtin_symbols.contains(&import)
+                    && !stdlib_symbols.contains(&import)
+                    && !dylink_symbols.contains(&import)
+                {
+                    missing_symbols.push(import);
                 }
             }
         }

crates/config/Cargo.toml

@@ -5,6 +5,7 @@ description = "User configuration of tree-sitter's command line programs"
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
+readme = "README.md"
 homepage.workspace = true
 repository.workspace = true
 documentation = "https://docs.rs/tree-sitter-config"

crates/config/src/tree_sitter_config.rs

@@ -28,24 +28,14 @@ pub enum ConfigError {
 #[derive(Debug, Error)]
 pub struct IoError {
     pub error: std::io::Error,
-    pub path: Option<PathBuf>,
+    pub path: Option<String>,
 }
 
-impl PartialEq for IoError {
-    fn eq(&self, other: &Self) -> bool {
-        self.path == other.path
-            && self.error.kind() == other.error.kind()
-            && self.error.raw_os_error() == other.error.raw_os_error()
-    }
-}
-
-impl Eq for IoError {}
-
 impl IoError {
     fn new(error: std::io::Error, path: Option<&Path>) -> Self {
         Self {
             error,
-            path: path.map(Path::to_path_buf),
+            path: path.map(|p| p.to_string_lossy().to_string()),
         }
     }
 }
@@ -54,7 +44,7 @@ impl std::fmt::Display for IoError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.error)?;
         if let Some(ref path) = self.path {
-            write!(f, " ({})", path.display())?;
+            write!(f, " ({path})")?;
         }
         Ok(())
     }

crates/generate/Cargo.toml

@@ -5,6 +5,7 @@ description = "Library for generating C source code from a tree-sitter grammar"
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
+readme = "README.md"
 homepage.workspace = true
 repository.workspace = true
 documentation = "https://docs.rs/tree-sitter-generate"
@@ -19,24 +20,30 @@ path = "src/generate.rs"
 workspace = true
 
 [features]
-default = [ "qjs-rt" ]
-load = [ "dep:semver" ]
-qjs-rt = [ "load", "rquickjs", "pathdiff" ]
+default = ["qjs-rt"]
+load = ["dep:semver"]
+qjs-rt = ["load", "rquickjs", "pathdiff"]
 
 [dependencies]
-bitflags = "2.11.1"
+bitflags = "2.9.4"
 dunce = "1.0.5"
-hashbrown.workspace = true
 indexmap.workspace = true
+indoc.workspace = true
 log.workspace = true
-pathdiff = { optional = true, version = "0.2.3" }
+pathdiff = { version = "0.2.3", optional = true }
 regex.workspace = true
 regex-syntax.workspace = true
-rquickjs = { features = [ "bindgen", "loader", "macro", "phf" ], optional = true, version = "0.13" }
+rquickjs = { version = "0.10.0", optional = true, features = [
+  "bindgen",
+  "loader",
+  "macro",
+  "phf",
+] }
 rustc-hash.workspace = true
-semver = { optional = true, workspace = true }
+semver = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
+smallbitvec.workspace = true
 thiserror.workspace = true
 topological-sort.workspace = true
 

crates/generate/src/bitvec.rs

@@ -1,415 +0,0 @@
-use std::{
-    hash::{Hash, Hasher},
-    ptr,
-};
-
-const ARENA_CHUNK_WORDS: usize = 128 * 1024 / std::mem::size_of::<u64>();
-
-struct WordArena {
-    chunks: Vec<Vec<u64>>,
-    offset: usize,
-    /// Freed blocks grouped by size (number of words). Checked before
-    /// bump-allocating so that dropped `BitVec`s can be reused immediately.
-    free_list: Vec<(usize, Vec<*mut u64>)>,
-}
-
-impl WordArena {
-    const fn new() -> Self {
-        Self {
-            chunks: Vec::new(),
-            offset: ARENA_CHUNK_WORDS, // forces first alloc to create a chunk
-            free_list: Vec::new(),
-        }
-    }
-
-    #[inline]
-    fn alloc(&mut self, n_words: usize) -> *mut u64 {
-        if n_words == 0 {
-            return std::ptr::NonNull::<u64>::dangling().as_ptr();
-        }
-        // Check the free list before bump-allocating.
-        if let Some((_, bucket)) = self.free_list.iter_mut().find(|(s, _)| *s == n_words)
-            && let Some(ptr) = bucket.pop()
-        {
-            return ptr;
-        }
-        if self.offset + n_words > ARENA_CHUNK_WORDS {
-            let size = ARENA_CHUNK_WORDS.max(n_words);
-            self.chunks.push(vec![0u64; size]);
-            self.offset = 0;
-        }
-        let chunk = self.chunks.last_mut().unwrap();
-        // SAFETY: Either a new chunk was just created with len = ARENA_CHUNK_WORDS.max(n_words),
-        // in which case offset = 0 and n_words <= len; or an existing chunk is reused, in which
-        // case offset + n_words <= ARENA_CHUNK_WORDS <= chunk.len().
-        let ptr = unsafe { chunk.as_mut_ptr().add(self.offset) };
-        self.offset += n_words;
-        ptr
-    }
-
-    #[inline]
-    fn free(&mut self, ptr: *mut u64, n_words: usize, used_words: usize) {
-        if n_words == 0 {
-            return;
-        }
-        // Zero only the in-use words; the rest are already zero by the BitVec
-        // invariant (data[words_in_use..capacity] is always zero).
-        // SAFETY: ptr was returned by alloc(n_words) and is valid for n_words
-        // words; used_words <= n_words.
-        if used_words > 0 {
-            unsafe { std::slice::from_raw_parts_mut(ptr, used_words).fill(0) };
-        }
-        if let Some((_, bucket)) = self.free_list.iter_mut().find(|(s, _)| *s == n_words) {
-            bucket.push(ptr);
-        } else {
-            self.free_list.push((n_words, vec![ptr]));
-        }
-    }
-}
-
-thread_local! {
-    static WORD_ARENA: std::cell::RefCell<WordArena> = const { std::cell::RefCell::new(WordArena::new()) };
-}
-
-#[inline]
-fn arena_alloc(n_words: usize) -> *mut u64 {
-    WORD_ARENA.with(|a| a.borrow_mut().alloc(n_words))
-}
-
-#[inline]
-fn arena_free(ptr: *mut u64, n_words: usize, used_words: usize) {
-    WORD_ARENA.with(|a| a.borrow_mut().free(ptr, n_words, used_words));
-}
-
-/// A bit vector whose backing `u64` words are bump-allocated from a global
-/// arena. Token sets are OR'd together many times and doing this at the word
-/// level rather than bit-by-bit is much faster.
-pub struct BitVec {
-    /// Pointer into arena chunk data. Dangling when `capacity == 0`.
-    data: *mut u64,
-    num_bits: u32,
-    /// Number of allocated words (_not_ bytes) in the arena region.
-    capacity: u32,
-}
-
-impl BitVec {
-    #[must_use]
-    pub const fn new() -> Self {
-        Self {
-            data: ptr::NonNull::dangling().as_ptr(),
-            num_bits: 0,
-            capacity: 0,
-        }
-    }
-
-    #[must_use]
-    pub fn with_capacity(n_bits: usize) -> Self {
-        let n_words = n_bits.div_ceil(64);
-        if n_words == 0 {
-            return Self::new();
-        }
-        Self {
-            data: arena_alloc(n_words),
-            num_bits: 0,
-            capacity: n_words as u32,
-        }
-    }
-
-    #[inline]
-    const fn words_in_use(&self) -> usize {
-        (self.num_bits as usize).div_ceil(64)
-    }
-
-    /// View the in-use words as a slice.
-    #[inline]
-    #[must_use]
-    pub const fn as_slice(&self) -> &[u64] {
-        let n = self.words_in_use();
-        if n == 0 {
-            &[]
-        } else {
-            // SAFETY: data points to at least `capacity` valid words, and
-            // words_in_use() <= capacity.
-            unsafe { std::slice::from_raw_parts(self.data, n) }
-        }
-    }
-
-    /// View all `capacity` allocated words as a mutable slice.
-    #[inline]
-    const fn as_full_slice_mut(&mut self) -> &mut [u64] {
-        let n = self.capacity as usize;
-        if n == 0 {
-            return &mut [];
-        }
-        // SAFETY: data points to `capacity` valid words.
-        unsafe { std::slice::from_raw_parts_mut(self.data, n) }
-    }
-
-    #[must_use]
-    #[allow(clippy::len_without_is_empty)]
-    pub const fn len(&self) -> usize {
-        self.num_bits as usize
-    }
-
-    #[must_use]
-    pub const fn get(&self, index: usize) -> Option<bool> {
-        if index >= self.num_bits as usize {
-            return None;
-        }
-        Some(self.as_slice()[index / 64] >> (index % 64) & 1 != 0)
-    }
-
-    pub const fn set(&mut self, index: usize, val: bool) {
-        let word_idx = index / 64;
-        let bit_idx = index % 64;
-        let words = self.as_full_slice_mut();
-        if val {
-            words[word_idx] |= 1u64 << bit_idx;
-        } else {
-            words[word_idx] &= !(1u64 << bit_idx);
-        }
-    }
-
-    /// Grow the backing storage so that the arena region holds at least
-    /// `n_words` words, copying existing data into the new region.
-    fn ensure_words(&mut self, n_words: usize) {
-        if n_words > self.capacity as usize {
-            let new_cap = n_words.max((self.capacity as usize) * 2);
-            let new_data = arena_alloc(new_cap);
-            let old = self.words_in_use();
-            if old > 0 {
-                // SAFETY: new_data points to new_cap valid zeroed words; old <= capacity.
-                let dst = unsafe { std::slice::from_raw_parts_mut(new_data, old) };
-                dst.copy_from_slice(self.as_slice());
-            }
-            let old_cap = self.capacity;
-            let old_data = self.data;
-            self.data = new_data;
-            self.capacity = new_cap as u32;
-            arena_free(old_data, old_cap as usize, old);
-        }
-    }
-
-    pub fn resize(&mut self, new_len: usize, val: bool) {
-        let new_words = new_len.div_ceil(64);
-        let old_words = self.words_in_use();
-        self.ensure_words(new_words);
-        let fill = if val { !0u64 } else { 0u64 };
-        let words = self.as_full_slice_mut();
-        if new_words > old_words {
-            words[old_words..new_words].fill(fill);
-            // When setting bits to true, clear any bits in the last word that
-            // fall beyond new_len to preserve the invariant that bits >= num_bits
-            // are always zero.
-            if val && !new_len.is_multiple_of(64) {
-                let mask = (1u64 << (new_len % 64)) - 1;
-                words[new_words - 1] &= mask;
-            }
-        } else if new_words < old_words {
-            // Zero out truncated words so stale data is never visible.
-            words[new_words..old_words].fill(0);
-        }
-        self.num_bits = new_len as u32;
-    }
-
-    #[must_use]
-    pub const fn last(&self) -> Option<bool> {
-        if self.num_bits == 0 {
-            return None;
-        }
-        self.get(self.num_bits as usize - 1)
-    }
-
-    pub const fn pop(&mut self) -> Option<bool> {
-        if self.num_bits == 0 {
-            return None;
-        }
-        self.num_bits -= 1;
-        let word_idx = self.num_bits as usize / 64;
-        let bit_idx = self.num_bits as usize % 64;
-        let new_words_in_use = self.words_in_use();
-        let words = self.as_full_slice_mut();
-        let val = words[word_idx] >> bit_idx & 1 != 0;
-        if val {
-            words[word_idx] &= !(1u64 << bit_idx);
-        }
-        // Zero out the word if it's no longer in use.
-        if word_idx >= new_words_in_use {
-            words[word_idx] = 0;
-        }
-        Some(val)
-    }
-
-    /// Word-level OR: self |= other. Returns true if any new bits were set.
-    #[inline]
-    pub fn insert_all(&mut self, other: &Self) -> bool {
-        let other_words = other.words_in_use();
-        if other_words == 0 {
-            return false;
-        }
-        let self_words = self.words_in_use();
-        if other_words > self.capacity as usize {
-            // Need a larger arena region.
-            let new_data = arena_alloc(other_words);
-            if self_words > 0 {
-                // SAFETY: new_data points to other_words valid zeroed words; self_words <= capacity.
-                let dst = unsafe { std::slice::from_raw_parts_mut(new_data, self_words) };
-                dst.copy_from_slice(self.as_slice());
-            }
-            // Arena memory is pre-zeroed, so words self_words..other_words are already 0.
-            let old_cap = self.capacity;
-            let old_data = self.data;
-            self.data = new_data;
-            self.capacity = other_words as u32;
-            arena_free(old_data, old_cap as usize, self_words);
-        } else if other_words > self_words {
-            // Have capacity, but clear any stale data in the region we're about to OR into.
-            self.as_full_slice_mut()[self_words..other_words].fill(0);
-        }
-        if other.num_bits > self.num_bits {
-            self.num_bits = other.num_bits;
-        }
-        let other_slice = other.as_slice();
-        let self_slice = &mut self.as_full_slice_mut()[..other_words];
-        let mut any_new = 0u64;
-        for (sw, &ow) in self_slice.iter_mut().zip(other_slice) {
-            let new_bits = ow & !*sw;
-            *sw |= ow;
-            any_new |= new_bits;
-        }
-        any_new != 0
-    }
-}
-
-impl Drop for BitVec {
-    fn drop(&mut self) {
-        if self.capacity > 0 {
-            arena_free(self.data, self.capacity as usize, self.words_in_use());
-        }
-    }
-}
-
-impl Default for BitVec {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Clone for BitVec {
-    fn clone(&self) -> Self {
-        let words = self.words_in_use();
-        if words == 0 {
-            return Self::new();
-        }
-        let new_data = arena_alloc(words);
-        // SAFETY: new_data points to `words` valid zeroed words.
-        let dst = unsafe { std::slice::from_raw_parts_mut(new_data, words) };
-        dst.copy_from_slice(self.as_slice());
-        Self {
-            data: new_data,
-            num_bits: self.num_bits,
-            capacity: words as u32,
-        }
-    }
-}
-
-impl PartialEq for BitVec {
-    fn eq(&self, other: &Self) -> bool {
-        let a = self.as_slice();
-        let b = other.as_slice();
-        let max_len = a.len().max(b.len());
-        for i in 0..max_len {
-            if a.get(i).copied().unwrap_or(0) != b.get(i).copied().unwrap_or(0) {
-                return false;
-            }
-        }
-        true
-    }
-}
-
-impl Eq for BitVec {}
-
-impl Hash for BitVec {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        let data = self.as_slice();
-        let effective_len = data.iter().rposition(|&w| w != 0).map_or(0, |i| i + 1);
-        data[..effective_len].hash(state);
-    }
-}
-
-impl Ord for BitVec {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        let a = self.as_slice();
-        let b = other.as_slice();
-        let max_len = a.len().max(b.len());
-        for i in 0..max_len {
-            let aw = a.get(i).copied().unwrap_or(0);
-            let bw = b.get(i).copied().unwrap_or(0);
-            if aw != bw {
-                let first_diff = (aw ^ bw).trailing_zeros();
-                return if (aw >> first_diff) & 1 != 0 {
-                    std::cmp::Ordering::Greater
-                } else {
-                    std::cmp::Ordering::Less
-                };
-            }
-        }
-        std::cmp::Ordering::Equal
-    }
-}
-
-impl PartialOrd for BitVec {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl std::ops::Index<usize> for BitVec {
-    type Output = bool;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        static TRUE: bool = true;
-        static FALSE: bool = false;
-        if self.as_slice()[index / 64] >> (index % 64) & 1 != 0 {
-            &TRUE
-        } else {
-            &FALSE
-        }
-    }
-}
-
-/// Iterator that yields only the indices of set bits, skipping zero words
-/// entirely and using `trailing_zeros()` within each word.
-pub struct SetBitsIter<'a> {
-    data: &'a [u64],
-    word_idx: usize,
-    current_word: u64,
-}
-
-impl<'a> SetBitsIter<'a> {
-    #[must_use]
-    pub fn new(data: &'a [u64]) -> Self {
-        Self {
-            data,
-            word_idx: 0,
-            current_word: data.first().copied().unwrap_or(0),
-        }
-    }
-}
-
-impl Iterator for SetBitsIter<'_> {
-    type Item = usize;
-
-    fn next(&mut self) -> Option<usize> {
-        while self.current_word == 0 {
-            self.word_idx += 1;
-            if self.word_idx >= self.data.len() {
-                return None;
-            }
-            self.current_word = self.data[self.word_idx];
-        }
-        let bit = self.current_word.trailing_zeros() as usize;
-        self.current_word &= self.current_word - 1; // clear lowest set bit
-        Some(self.word_idx * 64 + bit)
-    }
-}