@neralabs/rerail-pack-rust 0.1.3 → 0.1.4

package/README.md

@@ -1,35 +1,36 @@
 # Rerail rule pack: Rust
 
-Ports of 34 Clippy 0.1.99 lints, all candidates: they live in `candidates/rules/` and move to `rules/` and `pack.json` once they pass the V1 rule validation gates ([nera-rule-validation](https://github.com/neralabs/nera-rule-validation)). While `pack.json` lists no rules, the pack ships none and is never recommended. Each port is scored against Clippy's recorded findings on its UI tests and on pinned ripgrep and tokio checkouts, through the engine's production workspace path, with every disagreement declared in `divergences.json` (218 entries, each with its evidence).
+Ports of 34 Clippy 0.1.99 lints. Eighteen pass the [port readiness gates](../../docs/port-readiness.md) and ship in `rules/` and `pack.json`: `clippy-builtin-type-shadow`, `clippy-inconsistent-digit-grouping`, `clippy-int-plus-one`, `clippy-large-digit-groups`, `clippy-many-single-char-names`, `clippy-mixed-case-hex-literals`, `clippy-needless-arbitrary-self-type`, `clippy-needless-else`, `clippy-needless-raw-string-hashes`, `clippy-octal-escapes`, `clippy-partial-pub-fields`, `clippy-precedence`, `clippy-precedence-bits`, `clippy-redundant-at-rest-pattern`, `clippy-single-component-path-imports`, `clippy-unneeded-wildcard-pattern`, `clippy-unusual-byte-groupings` and `clippy-zero-prefixed-literal`. Clippy's default lint levels leave `large_digit_groups`, `many_single_char_names` and `needless_raw_string_hashes` (pedantic) and `partial_pub_fields` and `precedence_bits` (restriction) off, so they ship off (`"on": false`). The other 16 are candidates in `candidates/rules/`, judged by the same gates without blocking; the four that port a non-default `clippy.toml` (`-threshold`, `-no-fractions`, `-one-allowed`) stay candidates whatever they score, since the gates judge them against Clippy's defaults. Each port is scored against Clippy's recorded findings on its UI tests and on pinned ripgrep and tokio checkouts, through the engine's production workspace path, with its disagreements declared in `divergences.json` (214 entries, each with its evidence); the candidate `clippy-option-env-unwrap`'s two on `tests/ui/option_env_unwrap.rs` (an `external!` proc macro that rewrites its tokens' spans, which syntax alone cannot tell from a span-keeping macro) are the only ones left undeclared.
 
 This pack follows the [pack structure and validation contract](../../docs/pack-format.md) and is checked by `npx vitest run test/engine/catalog/packs.test.ts`.
 
 | Path | What |
 |---|---|
-| `pack.json` | The pack (`rerail.rule-pack/v1`): its match definition, and no rules until a port passes |
-| `candidates/rules/` | The code-rule documents (`rerail.policy/v1`) of the ports, scored but never shipped |
+| `pack.json` | The pack (`rerail.rule-pack/v1`): its match definition, and each shipped rule's document, title, group and whether it is on |
+| `rules/` | The code-rule documents (`rerail.policy/v1`) of the ports that pass the port readiness gates |
+| `candidates/rules/` | The code-rule documents of the other ports, scored and judged but never shipped |
 | `conformance.json` | Each ported lint's upstream tool and rule, how findings compare, and the capabilities it exercises; the pinned Clippy tool and corpora |
 | `divergences.json` | Declared disagreements with Clippy |
-| `upstream/clippy/` | Clippy's copied UI tests, the probes Rerail wrote (`fixtures/rerail/`, listed in `UPSTREAM.md`), recordings and recorder (`generate.py`, sharing `upstream/common.py`) |
+| `upstream/clippy/` | Clippy's copied UI tests, the probes Rerail wrote (`fixtures/rerail/`, listed in `UPSTREAM.md`), recordings and recorder (`generate.py`, sharing `upstream/common.py`); the port readiness gates' `gates.yaml`, `recording.lock` and `goldens.tsv` |
 | `licenses/clippy/` | Clippy's licence and `UPSTREAM.md`, listing every copied file |
 
 ## Scores
 
-Every port is a candidate: scored and reported, never gating a check. Scored with `node --import tsx conformance/languages/cli.ts --pack rust` (Clippy 0.1.99, Rust 1.99.0; fixtures and both
+Every port, shipped or candidate, is scored here. Scored with `node --import tsx conformance/languages/cli.ts --pack rust` (Clippy 0.1.99, Rust 1.99.0; fixtures and both
 corpora). FP and FN count unexplained points only; an explained point is one a divergence names, and recall counts
 an explained FN against the pack.
 
 | Source | Rules | TP | FP | FN | Explained FP | Explained FN |
 |---|---|---|---|---|---|---|
-| fixtures (Clippy's UI tests and Rerail's probes) | 34 | 393 | 0 | 0 | 0 | 11 |
+| fixtures (Clippy's UI tests and Rerail's probes) | 34 | 397 | 2 | 2 | 0 | 7 |
 | ripgrep corpus | 34 | 614 | 0 | 0 | 11 | 6 |
-| tokio corpus | 34 | 553 | 0 | 0 | 98 | 95 |
+| tokio corpus | 34 | 555 | 0 | 0 | 98 | 95 |
 
 Divergences by kind (`divergences.json`):
 
 | Kind | fixtures | ripgrep | tokio | Total | What |
 |---|---|---|---|---|---|
-| `rerail-unknown` | 11 | 2 | 90 | 103 | Code tree-sitter-rust holds as macro token trees or `macro_rules!` bodies, which Clippy lints after expansion; `box` patterns tree-sitter-rust does not parse; an attribute on a tuple element expression; a decimal literal at or above 2^52, which a rule's JSON-number bounds cannot name |
+| `rerail-unknown` | 7 | 2 | 90 | 99 | Code tree-sitter-rust holds as macro token trees or `macro_rules!` bodies, which Clippy lints after expansion; `box` patterns tree-sitter-rust does not parse; an attribute on a tuple element expression; a decimal literal at or above 2^53, which a rule's JSON-number bounds cannot name |
 | `not-comparable` | 0 | 15 | 100 | 115 | Items and files a `cfg` leaves out of the recording's build (macOS, `--all-features`, no `tokio_unstable`, `loom`, `docsrs` or `miri`), `cfg_attr` levels whose predicate is false there, `#[tokio::test]`'s expansion, grep-index's crate-root `#![allow(warnings)]` (read per file), and the ui-toml variants on corpora recorded with Clippy's defaults |
 | `upstream-wrong` | 0 | 0 | 0 | 0 | |
 
@@ -38,8 +39,8 @@ Per rule (TP / FP / FN, explained points in parentheses):
 | Rule | fixtures | ripgrep | tokio |
 |---|---|---|---|
 | `clippy-precedence` | 30 / 0 / 0 | 0 / 0 / 0 | 0 / 0 / 0 |
-| `clippy-precedence-bits` | 24 / 0 / 0 | 0 / 0 / 0 | 2 / 0 / 0 |
-| `clippy-double-parens` | 20 / 0 / 0 (5) | 0 / 0 / 0 | 0 / 0 / 0 |
+| `clippy-precedence-bits` | 26 / 0 / 0 | 0 / 0 / 0 | 4 / 0 / 0 |
+| `clippy-double-parens` | 24 / 0 / 0 (1) | 0 / 0 / 0 | 0 / 0 / 0 |
 | `clippy-int-plus-one` | 14 / 0 / 0 | 0 / 0 / 0 | 0 / 0 / 0 |
 | `clippy-redundant-static-lifetimes` | 31 / 0 / 0 | 32 / 0 / 0 (2) | 0 / 0 / 0 |
 | `clippy-needless-arbitrary-self-type` | 9 / 0 / 0 | 0 / 0 / 0 | 0 / 0 / 0 |
@@ -49,7 +50,7 @@ Per rule (TP / FP / FN, explained points in parentheses):
 | `clippy-redundant-at-rest-pattern` | 6 / 0 / 0 | 0 / 0 / 0 | 0 / 0 / 0 |
 | `clippy-needless-else` | 1 / 0 / 0 | 0 / 0 / 0 | 0 / 0 / 0 |
 | `clippy-unnested-or-patterns` | 32 / 0 / 0 (3) | 4 / 0 / 0 | 1 / 0 / 0 |
-| `clippy-option-env-unwrap` | 7 / 0 / 0 | 0 / 0 / 0 | 0 / 0 / 0 |
+| `clippy-option-env-unwrap` | 5 / 2 / 2 | 0 / 0 / 0 | 0 / 0 / 0 |
 | `clippy-unreadable-literal` | 16 / 0 / 0 | 5 / 0 / 0 (1) | 0 / 0 / 0 (1) |
 | `clippy-unreadable-literal-no-fractions` | 1 / 0 / 0 | 5 / 0 / 0 (1) | 0 / 0 / 0 (1) |
 | `clippy-inconsistent-digit-grouping` | 9 / 0 / 0 | 0 / 0 / 0 | 0 / 0 / 0 |
@@ -74,11 +75,19 @@ Per rule (TP / FP / FN, explained points in parentheses):
 
 ## Recording and scoring
 
-Re-recording runs offline against Clippy 0.1.99 and Rust 1.99.0:
+Re-recording is a maintainer deriving the pack's test data from its pins and archiving it
+([CONTRIBUTING.md](../../CONTRIBUTING.md#pack-test-data)); it is never committed. The recipe
+(`scripts/pack-data/recipes/rust.ts`) runs `upstream/clippy/generate.py` against Clippy 0.1.99 and Rust 1.99.0
+(installed with `rustup`), in `fixtures` mode and then `corpus` mode over ripgrep and tokio. Derive it on Linux, as the
+bump workflow does: tokio has `#[cfg(target_os = "linux")]` code, so `corpus-tokio.expected.json` derived on macOS
+differs. The same holds for the port readiness recordings; a pull request's CI legs record them on Linux and upload
+them as the artifact `recordings-rust--clippy` ([CONTRIBUTING.md](../../CONTRIBUTING.md#merging-maintainers)).
+The probes Rerail wrote (`fixtures/rerail/`) are authored: a change to them goes in your pull request with
+`git add -f`.
 
 ```sh
-python3 upstream/clippy/generate.py fixtures <rust-clippy checkout at tag rust-1.99.0> <scratch directory>
-python3 upstream/clippy/generate.py corpus <cargo target root> ripgrep=<ripgrep checkout> tokio=<tokio checkout>
+npm run fixtures:derive -- --pack rust
+npm run fixtures:push -- --pack rust     # on your own branch: archive it and rewrite its test-data.lock
 ```
 
 Scoring one rule with every false positive and false negative printed:
@@ -87,6 +96,15 @@ Scoring one rule with every false positive and false negative printed:
 node --import tsx conformance/languages/cli.ts --pack rust --rule clippy-precedence --fixtures
 ```
 
+The port readiness gates judge every port against their own recording of Clippy (`upstream/clippy/recording.lock`;
+the recorder runs the rustup toolchain `conformance/recorders/port-readiness/runtimes/clippy-1.99.0/` pins, on the
+same UI tests and corpora, as `generate.py` does):
+
+```sh
+npm run port-readiness:record -- --pack rust --tool clippy   # needs rustup, git and the network
+npm run port-readiness -- --pack rust --tool clippy
+```
+
 ## Rule details
 
 What each rule matches beyond its one-line description: exact matching, edge cases, upstream settings and known divergences.
@@ -97,19 +115,27 @@ Port of Clippy 0.1.99's allow_attributes: reports the path of every outer #[allo
 
 ### `clippy-allow-attributes-without-reason`
 
-Port of Clippy 0.1.99's allow_attributes_without_reason: reports every #[allow(..)] and #[expect(..)] attribute, inner or outer, one a #[cfg_attr(..)] expands to included (at the expanded attribute), whose last item is not `reason = ".."`. The lint needs Rust 1.81 (lint reasons, `suppress.clippy.msrv`). What a macro invocation's or macro_rules! body's token tree holds, and whether a #[cfg] predicate holds in a build, are not read. A #[cfg_attr] is read as active unless its first argument is exactly `test`, `any()` or `not(clippy)`, the predicates the suppression engine reads as off whatever the build; every other predicate is read as active. Each allow or expect a #[cfg_attr] expands to is checked on its own for a last `reason = ".."` item.
+Port of Clippy 0.1.99's allow_attributes_without_reason: reports every #[allow(..)] and #[expect(..)] attribute, inner or outer, one a #[cfg_attr(..)] expands to included (at the expanded attribute), whose last item is not `reason = ".."`. The lint needs Rust 1.81 (lint reasons, `suppress.clippy.msrv`). What a macro invocation's or macro_rules! body's token tree holds, and whether a #[cfg] predicate holds in a build, are not read. A #[cfg_attr] is read as active unless its first argument is exactly `test`, `any()` or `not(clippy)`, the predicates the suppression engine reads as off whatever the build; every other predicate is read as active. Each allow or expect a #[cfg_attr] expands to is checked on its own for a last `reason = ".."` item and reported at its own span (`allow(..)`, as Clippy reports the expanded attribute); a list nested deeper than two parentheses inside it is not read.
+
+### `clippy-builtin-type-shadow`
+
+Port of Clippy 0.1.99's builtin_type_shadow: reports generic type parameters named like a primitive type (rustc's PrimTy names: the integer types, the float types f16 to f128, bool, char and str); semantic name resolution is not modelled.
 
 ### `clippy-decimal-literal-representation`
 
-Port of Clippy 0.1.99's decimal_literal_representation (literal-representation-threshold 16384, the default): reports a decimal integer literal whose value is at least the threshold and whose hexadecimal digits are a power of two with a margin (1, 2, 4 or 8 then zeros, or 1, 3, 7 or F then Fs, the last digit free) or only 0s and Fs after a leading 7 or F. Values of 2^52 and above are not read (the thresholds are JSON numbers); macro arguments and macro_rules! bodies are token trees no syntax-level reader expands.
+Port of Clippy 0.1.99's decimal_literal_representation (literal-representation-threshold 16384, the default): reports a decimal integer literal whose value is at least the threshold and whose hexadecimal digits (four or more above this threshold) are a power of two with a margin (1, 2, 4 or 8 then zeros, or 1, 3, 7 or F then Fs, the last digit free: a value at most 16 below or 15 above a power of two) or only 0s and Fs after a leading 7 or F (every hexadecimal digit 0 or F, the leading one possibly 7). Values of 2^53 and above are not read: the rule language has no hexadecimal reading of a value, so the digits are read as value ranges and bit masks, and a rule's numbers reach the engine as JavaScript numbers, exact only up to 2^53. Macro arguments and macro_rules! bodies are token trees no syntax-level reader expands.
 
 ### `clippy-decimal-literal-representation-threshold`
 
-Port of Clippy 0.1.99's decimal_literal_representation under literal-representation-threshold = 0xFFFFFF (its ui-toml test): reports a decimal integer literal whose value is at least the threshold and whose hexadecimal digits are a power of two with a margin (1, 2, 4 or 8 then zeros, or 1, 3, 7 or F then Fs, the last digit free) or only 0s and Fs after a leading 7 or F. Values of 2^52 and above are not read (the thresholds are JSON numbers); macro arguments and macro_rules! bodies are token trees no syntax-level reader expands.
+Port of Clippy 0.1.99's decimal_literal_representation under literal-representation-threshold = 0xFFFFFF (its ui-toml test): reports a decimal integer literal whose value is at least the threshold and whose hexadecimal digits (four or more above this threshold) are a power of two with a margin (1, 2, 4 or 8 then zeros, or 1, 3, 7 or F then Fs, the last digit free: a value at most 16 below or 15 above a power of two) or only 0s and Fs after a leading 7 or F (every hexadecimal digit 0 or F, the leading one possibly 7). Values of 2^53 and above are not read: the rule language has no hexadecimal reading of a value, so the digits are read as value ranges and bit masks, and a rule's numbers reach the engine as JavaScript numbers, exact only up to 2^53. Macro arguments and macro_rules! bodies are token trees no syntax-level reader expands.
 
 ### `clippy-double-parens`
 
-Port of Clippy 0.1.99's double_parens lint: reports redundant nested parentheses around an expression (only whitespace between the two opening or closing parentheses, as Clippy's source check requires; a call's sole argument in parentheses, reported once where the nested-parentheses clauses already report the same span); macro expansion and tuple/unit argument semantics are not modelled.
+Port of Clippy 0.1.99's double_parens lint: reports redundant nested parentheses around an expression (only whitespace between the two opening or closing parentheses, as Clippy's source check requires; a call's sole argument in parentheses, reported once where the nested-parentheses clauses already report the same span), and the same two shapes in a macro_rules! transcriber's tokens (a parenthesized group whose only content is another parenthesized group, in expression position after `=`, `=>`, `return`, a delimiter, `;` or `,`, or as the sole parenthesized argument after a call's name; a `$(` repetition is not a parenthesized expression); expansion of macro invocations' arguments and tuple/unit argument semantics are not modelled.
+
+### `clippy-else-if-without-else`
+
+Port of Clippy 0.1.99's else_if_without_else lint: reports the if expression of an else-if branch whose final if has no else, spanning the whole else-if expression; macro expansion and cfg evaluation are not modelled.
 
 ### `clippy-inconsistent-digit-grouping`
 
@@ -155,17 +181,21 @@ Port of Clippy 0.1.99's needless_raw_strings: reports raw literals whose content
 
 Port of Clippy 0.1.99's octal_escapes: reports each \0 followed by one or two octal digits in string, byte-string, or C-string literals; format-string preprocessing and external macros are not modelled.
 
+### `clippy-option-env-unwrap`
+
+Port of Clippy 0.1.99's option_env_unwrap: reports an unwrap or expect call on option_env!, spanning the whole call; inside a token tree (a macro invocation's input or a macro_rules! body) it reports the call where its tokens are written, as Clippy does for macros that keep their input's spans (macro_rules!, format macros) and for a macro_rules! body that is expanded; a proc macro that respans its input, which Clippy reports at the invocation, is not modelled.
+
 ### `clippy-partial-pub-fields`
 
-Port of Clippy 0.1.99's partial_pub_fields: in a struct whose first field is `pub` (exactly: `pub(crate)` and other restricted visibilities are not), reports the first field that is not, and in one whose first field is not `pub`, the first field that is, at the field's visibility (its start when it has none).
+Port of Clippy 0.1.99's partial_pub_fields: in a struct whose first field is `pub` (exactly: `pub(crate)` and other restricted visibilities are not), reports the first field that is not, and in one whose first field is not `pub`, the first field that is, at the field's visibility (a zero-width point at the field's start when it has none).
 
 ### `clippy-precedence`
 
-Port of Clippy 0.1.99's precedence lint: reports a shift or bitwise operation whose operand is an unparenthesized arithmetic (+ - * / %) operation, at every nesting depth; macro expansion and type/value semantics are not modelled.
+Port of Clippy 0.1.99's precedence lint: reports a shift or bitwise operation whose operand is an unparenthesized arithmetic (+ - * / %) operation, at every nesting depth, and a method call whose receiver is an unparenthesized closure (spanning the call); macro expansion and type/value semantics are not modelled.
 
 ### `clippy-precedence-bits`
 
-Port of Clippy 0.1.99's precedence_bits lint: reports, at any nesting depth, a bitwise (& | ^) operation with an unparenthesized shift operand and no unparenthesized arithmetic operand (that mix is the precedence lint's). Clippy reports every such operation, but operations sharing a start (a left-nested chain like `a ^ b ^ c >> 1 ^ d >> 2`) are one position, so one finding is made per chain, at the outermost operation; macro expansion and semantic type checks are not modelled.
+Port of Clippy 0.1.99's precedence_bits lint: reports, at any nesting depth, every bitwise (& | ^) operation with an unparenthesized shift operand and no unparenthesized arithmetic operand (that mix is the precedence lint's), each at its own span, so every operation of a left-nested chain like `a ^ b ^ c >> 1 ^ d >> 2` that has a shift operand is reported; macro expansion and semantic type checks are not modelled.
 
 ### `clippy-redundant-field-names`
 
@@ -183,6 +213,10 @@ Port of Clippy 0.1.99's single_char_lifetime_names: reports each single-characte
 
 Port of Clippy 0.1.99's single_component_path_imports (Rust 2018 and later): reports a module's (the file's or a `mod`'s) non-`pub` `use name;` without a rename, and each `name` of a `use {a, b};` without a prefix, unless a `macro_rules!` of that name comes before it in the module, a non-`pub` `use self::name..` of the module (or `use self::{name..}`) names it, or a path `self::name::..` outside `use` declarations does anywhere in the module. Clippy reads the module after macro expansion; macro arguments and macro_rules! bodies are token trees no syntax-level reader expands.
 
+### `clippy-unneeded-wildcard-pattern`
+
+Port of Clippy 0.1.99's unneeded_wildcard_pattern: reports the run of wildcard elements of a tuple or tuple-struct pattern adjacent to its rest pattern, and the trailing wildcard fields of a struct pattern before its rest, spanning them with their separators up to (or from) the rest pattern as Clippy does; elements nested more than two brackets deep and macro-expanded code are not modelled.
+
 ### `clippy-unnested-or-patterns`
 
 Port of Clippy 0.1.99's unnested_or_patterns: reports a match arm's, let's, if/while let's or parameter's pattern that holds an or-pattern Clippy nests: one with a parenthesised or-pattern among its alternatives, or with two alternatives (adjacent or not) built alike that differ in one sub-pattern at most: `&mut`, the same `x @`, `ref x @` or `mut x @` binding, a tuple, slice or tuple struct (same path) pattern whose differing element is not `..` on either side, among the first six, or a struct pattern (same path, both with or both without `..`, up to six fields in any order) whose other fields are the same, unless the two are the same shorthands only. The lint needs Rust 1.53 (`suppress.clippy.msrv`). Sub-patterns compare by their tokens, parentheses included. Macro arguments and macro_rules! bodies are token trees no syntax-level reader expands; `box` patterns (an unstable feature) do not parse.

package/licenses/clippy/UPSTREAM.md

@@ -2,7 +2,7 @@
 
 Upstream: [rust-lang/rust-clippy](https://github.com/rust-lang/rust-clippy/tree/49e2f89a2605a9a340e04955fdbefa9803e6027a) at tag `rust-1.99.0` (commit `49e2f89a2605a9a340e04955fdbefa9803e6027a`), the clippy shipped as `clippy 0.1.99 (b940084d7e 2026-09-28)` with Rust 1.99.0. License: MIT OR Apache-2.0 (Copyright (c) The Rust Project Contributors); [`LICENSE-MIT`](LICENSE-MIT), [`LICENSE-APACHE`](LICENSE-APACHE) and [`COPYRIGHT`](COPYRIGHT) are the upstream license files, copied verbatim at that tag.
 
-The files listed below are UI tests of the clippy lints the Rust pack ports (`packs/rust/conformance.json`), the auxiliary crates those tests build, and the `clippy.toml` files they read. They remain under clippy's license. Every other file under `upstream/clippy/` is Rerail's, under the Apache License 2.0 (this repository's `LICENSE`; `upstream/clippy/UPSTREAM.md` lists the cases under `fixtures/rerail/`): `generate.py`, `../common.py` and the recordings they write by running clippy (`fixtures.expected.json`, `fixtures.upstream-check.json`, `corpus-*.expected.json`).
+The files listed below are UI tests of the clippy lints the Rust pack ports (`packs/rust/conformance.json`), the auxiliary crates those tests build, and the `clippy.toml` files they read. They remain under clippy's license. The rule documents in `rules/` and `candidates/rules/` are Rerail's re-implementations of clippy's lints, published under the pack's licence expression, `Apache-2.0 AND MIT`, as `REUSE.toml` annotates them. Every other file under `upstream/clippy/` is Rerail's, under the Apache License 2.0 (this repository's `LICENSE`; `upstream/clippy/UPSTREAM.md` lists the cases under `fixtures/rerail/`): `generate.py`, `../common.py` and the recordings they write by running clippy (`fixtures.expected.json`, `fixtures.upstream-check.json`, `corpus-*.expected.json`), and the port readiness gates' `gates.yaml`, `recording.lock` and `goldens.tsv`. The port readiness recording itself is not in the tree and holds no clippy test text: it names each test file by path and sha256, and the gates fetch them from rust-clippy at the pinned commit.
 
 Paths are relative to `packs/rust/`; each file keeps its upstream path under `upstream/clippy/fixtures/`.
 

package/pack.json

@@ -3,7 +3,7 @@
   "id": "rust",
   "name": "Rust",
   "category": "language",
-  "covers": "No rules yet: its 34 Clippy 0.1.99 ports are candidates until they pass the V1 rule validation gates.",
+  "covers": "18 Clippy 0.1.99 lints ported to Rerail, 13 of them on and 5 off until turned on, each scored against Clippy's own recorded findings on its UI tests; 16 more ports are candidates until they pass the port readiness gates.",
   "reason": "matches Rust",
   "match": {
     "any": [
@@ -15,5 +15,119 @@
       }
     ]
   },
-  "rules": []
+  "rules": [
+    {
+      "id": "clippy-needless-arbitrary-self-type",
+      "document": "rules/clippy-needless-arbitrary-self-type.json",
+      "title": "Clippy needless_arbitrary_self_type: Type of `self` parameter is already by default `Self`",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-redundant-at-rest-pattern",
+      "document": "rules/clippy-redundant-at-rest-pattern.json",
+      "title": "Clippy redundant_at_rest_pattern: Checks for `[all @ ..]` where `all` would suffice",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-needless-else",
+      "document": "rules/clippy-needless-else.json",
+      "title": "Clippy needless_else: Empty else branch",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-octal-escapes",
+      "document": "rules/clippy-octal-escapes.json",
+      "title": "Clippy octal_escapes: String escape sequences looking like octal characters",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-needless-raw-string-hashes",
+      "document": "rules/clippy-needless-raw-string-hashes.json",
+      "title": "Clippy needless_raw_string_hashes: Suggests reducing the number of hashes around a raw string literal",
+      "group": "Clippy",
+      "on": false
+    },
+    {
+      "id": "clippy-single-component-path-imports",
+      "document": "rules/clippy-single-component-path-imports.json",
+      "title": "Clippy single_component_path_imports: Imports with single component path are redundant",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-many-single-char-names",
+      "document": "rules/clippy-many-single-char-names.json",
+      "title": "Clippy many_single_char_names: Too many single character bindings",
+      "group": "Clippy",
+      "on": false
+    },
+    {
+      "id": "clippy-builtin-type-shadow",
+      "document": "rules/clippy-builtin-type-shadow.json",
+      "title": "Clippy builtin_type_shadow: Shadowing a builtin type",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-inconsistent-digit-grouping",
+      "document": "rules/clippy-inconsistent-digit-grouping.json",
+      "title": "Clippy inconsistent_digit_grouping: Integer literals with digits grouped inconsistently",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-int-plus-one",
+      "document": "rules/clippy-int-plus-one.json",
+      "title": "Clippy int_plus_one: Instead of using `x >= y + 1`, use `x > y`",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-large-digit-groups",
+      "document": "rules/clippy-large-digit-groups.json",
+      "title": "Clippy large_digit_groups: Grouping digits into groups that are too large",
+      "group": "Clippy",
+      "on": false
+    },
+    {
+      "id": "clippy-mixed-case-hex-literals",
+      "document": "rules/clippy-mixed-case-hex-literals.json",
+      "title": "Clippy mixed_case_hex_literals: Hex literals whose letter digits are not consistently upper- or lowercased",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-partial-pub-fields",
+      "document": "rules/clippy-partial-pub-fields.json",
+      "title": "Clippy partial_pub_fields: Partial fields of a struct are public",
+      "group": "Clippy",
+      "on": false
+    },
+    {
+      "id": "clippy-precedence",
+      "document": "rules/clippy-precedence.json",
+      "title": "Clippy precedence: Operations where precedence may be unclear",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-precedence-bits",
+      "document": "rules/clippy-precedence-bits.json",
+      "title": "Clippy precedence_bits: Operations mixing bit shifting with bit combining/masking",
+      "group": "Clippy",
+      "on": false
+    },
+    {
+      "id": "clippy-unneeded-wildcard-pattern",
+      "document": "rules/clippy-unneeded-wildcard-pattern.json",
+      "title": "Clippy unneeded_wildcard_pattern: Tuple and struct patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`)",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-unusual-byte-groupings",
+      "document": "rules/clippy-unusual-byte-groupings.json",
+      "title": "Clippy unusual_byte_groupings: Binary or hex literals that aren't grouped by four",
+      "group": "Clippy"
+    },
+    {
+      "id": "clippy-zero-prefixed-literal",
+      "document": "rules/clippy-zero-prefixed-literal.json",
+      "title": "Clippy zero_prefixed_literal: Integer literals starting with `0`",
+      "group": "Clippy"
+    }
+  ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neralabs/rerail-pack-rust",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Rerail rule pack: Clippy rules ported to Rerail code rules.",
   "license": "Apache-2.0 AND MIT",
   "repository": {

package/rules/clippy-builtin-type-shadow.json

@@ -0,0 +1,13 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-builtin-type-shadow",
+  "revision": 2,
+  "mode": "steer",
+  "description": "Don't name a Rust generic type parameter after a primitive type such as u32 or bool; it shadows the real type inside the item.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [{
+    "id": "builtin-type-shadow",
+    "forbid": { "ast": { "language": "rust", "rule": { "kind": "type_identifier", "regex": "^(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize|f16|f32|f64|f128|bool|char|str)$", "inside": { "kind": "type_parameter", "stopBy": "end" } } } },
+    "violation": { "suppress": { "clippy": { "lints": ["clippy::builtin_type_shadow", "clippy::all", "clippy::style", "warnings"] } }, "anchor": "witness.span", "code": "builtin_type_shadow", "message": "Rename this type parameter, e.g. T instead of u32, so it doesn't shadow the primitive type." }
+  }]
+}

package/rules/clippy-inconsistent-digit-grouping.json

@@ -0,0 +1,40 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-inconsistent-digit-grouping",
+  "revision": 2,
+  "mode": "steer",
+  "description": "Group the digits of Rust decimal literals with underscores in equal-size groups, the same way in the integer part and the fraction.",
+  "scope": {"include": ["**/*"], "exclude": []},
+  "clauses": [
+    {
+      "id": "inconsistent",
+      "forbid": { "ast": { "language": "rust", "rule": { "all": [
+        {"any": [{"kind": "integer_literal"}, {"kind": "float_literal"}]},
+        { "all": [
+          {"not": {"inside": {"stopBy": "end", "kind": "macro_definition"}}},
+          {"not": {"regex": "^[0-9][0-9_]*_(?:8|16|32|64)$"}},
+          {"not": {"regex": "^0[xbo][0-9A-Fa-f_]*_(?:8|16|32|64)$"}},
+          {"not": {"regex": "^[0-9_.]*[eE][+-]?[0-9_]*_(?:32|64)$"}},
+          {"not": {"regex": "^0x[0-9A-Fa-f]{8}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{12}(?:_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)))?$"}},
+          { "any": [
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"all": [{"not": {"regex": "^[0-9]+(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}}, {"not": {"regex": "^(?:[0-9]{1,1}(?:_[0-9]{1})+|[0-9]{1,2}(?:_[0-9]{2})+|[0-9]{1,3}(?:_[0-9]{3})+|[0-9]{1,4}(?:_[0-9]{4})+|[0-9]{1,5}(?:_[0-9]{5})+|[0-9]{1,6}(?:_[0-9]{6})+|[0-9]{1,7}(?:_[0-9]{7})+|[0-9]{1,8}(?:_[0-9]{8})+|[0-9]{1,9}(?:_[0-9]{9})+|[0-9]{1,10}(?:_[0-9]{10})+|[0-9]{1,11}(?:_[0-9]{11})+|[0-9]{1,12}(?:_[0-9]{12})+|[0-9]{1,13}(?:_[0-9]{13})+|[0-9]{1,14}(?:_[0-9]{14})+|[0-9]{1,15}(?:_[0-9]{15})+|[0-9]{1,16}(?:_[0-9]{16})+|[0-9]{1,17}(?:_[0-9]{17})+|[0-9]{1,18}(?:_[0-9]{18})+|[0-9]{1,19}(?:_[0-9]{19})+|[0-9]{1,20}(?:_[0-9]{20})+|[0-9]{1,21}(?:_[0-9]{21})+|[0-9]{1,22}(?:_[0-9]{22})+|[0-9]{1,23}(?:_[0-9]{23})+|[0-9]{1,24}(?:_[0-9]{24})+|[0-9]{1,25}(?:_[0-9]{25})+|[0-9]{1,26}(?:_[0-9]{26})+|[0-9]{1,27}(?:_[0-9]{27})+|[0-9]{1,28}(?:_[0-9]{28})+|[0-9]{1,29}(?:_[0-9]{29})+|[0-9]{1,30}(?:_[0-9]{30})+|[0-9]{1,31}(?:_[0-9]{31})+|[0-9]{1,32}(?:_[0-9]{32})+|[0-9]{1,33}(?:_[0-9]{33})+|[0-9]{1,34}(?:_[0-9]{34})+|[0-9]{1,35}(?:_[0-9]{35})+|[0-9]{1,36}(?:_[0-9]{36})+|[0-9]{1,37}(?:_[0-9]{37})+|[0-9]{1,38}(?:_[0-9]{38})+|[0-9]{1,39}(?:_[0-9]{39})+|[0-9]{1,40}(?:_[0-9]{40})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}}]}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,5}|[0-9]{1,1}(?:_[0-9]{1})+|[0-9]{1,2}(?:_[0-9]{2})+|[0-9]{1,3}(?:_[0-9]{3})+|[0-9]{1,4}(?:_[0-9]{4})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"all": [{"regex": "^[^.]*\\..*$"}, {"not": {"regex": "^[0-9_]*\\.[0-9]*(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}}, {"not": {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+[0-9]{1,1}|(?:[0-9]{2}_)+[0-9]{1,2}|(?:[0-9]{3}_)+[0-9]{1,3}|(?:[0-9]{4}_)+[0-9]{1,4}|(?:[0-9]{5}_)+[0-9]{1,5}|(?:[0-9]{6}_)+[0-9]{1,6}|(?:[0-9]{7}_)+[0-9]{1,7}|(?:[0-9]{8}_)+[0-9]{1,8}|(?:[0-9]{9}_)+[0-9]{1,9}|(?:[0-9]{10}_)+[0-9]{1,10}|(?:[0-9]{11}_)+[0-9]{1,11}|(?:[0-9]{12}_)+[0-9]{1,12}|(?:[0-9]{13}_)+[0-9]{1,13}|(?:[0-9]{14}_)+[0-9]{1,14}|(?:[0-9]{15}_)+[0-9]{1,15}|(?:[0-9]{16}_)+[0-9]{1,16}|(?:[0-9]{17}_)+[0-9]{1,17}|(?:[0-9]{18}_)+[0-9]{1,18}|(?:[0-9]{19}_)+[0-9]{1,19}|(?:[0-9]{20}_)+[0-9]{1,20}|(?:[0-9]{21}_)+[0-9]{1,21}|(?:[0-9]{22}_)+[0-9]{1,22}|(?:[0-9]{23}_)+[0-9]{1,23}|(?:[0-9]{24}_)+[0-9]{1,24}|(?:[0-9]{25}_)+[0-9]{1,25}|(?:[0-9]{26}_)+[0-9]{1,26}|(?:[0-9]{27}_)+[0-9]{1,27}|(?:[0-9]{28}_)+[0-9]{1,28}|(?:[0-9]{29}_)+[0-9]{1,29}|(?:[0-9]{30}_)+[0-9]{1,30}|(?:[0-9]{31}_)+[0-9]{1,31}|(?:[0-9]{32}_)+[0-9]{1,32}|(?:[0-9]{33}_)+[0-9]{1,33}|(?:[0-9]{34}_)+[0-9]{1,34}|(?:[0-9]{35}_)+[0-9]{1,35}|(?:[0-9]{36}_)+[0-9]{1,36}|(?:[0-9]{37}_)+[0-9]{1,37}|(?:[0-9]{38}_)+[0-9]{1,38}|(?:[0-9]{39}_)+[0-9]{1,39}|(?:[0-9]{40}_)+[0-9]{1,40})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+|(?:[0-9]{2}_)+|(?:[0-9]{3}_)+|(?:[0-9]{4}_)+|(?:[0-9]{5}_)+|(?:[0-9]{6}_)+|(?:[0-9]{7}_)+|(?:[0-9]{8}_)+|(?:[0-9]{9}_)+|(?:[0-9]{10}_)+|(?:[0-9]{11}_)+|(?:[0-9]{12}_)+|(?:[0-9]{13}_)+|(?:[0-9]{14}_)+|(?:[0-9]{15}_)+|(?:[0-9]{16}_)+|(?:[0-9]{17}_)+|(?:[0-9]{18}_)+|(?:[0-9]{19}_)+|(?:[0-9]{20}_)+|(?:[0-9]{21}_)+|(?:[0-9]{22}_)+|(?:[0-9]{23}_)+|(?:[0-9]{24}_)+|(?:[0-9]{25}_)+|(?:[0-9]{26}_)+|(?:[0-9]{27}_)+|(?:[0-9]{28}_)+|(?:[0-9]{29}_)+|(?:[0-9]{30}_)+|(?:[0-9]{31}_)+|(?:[0-9]{32}_)+|(?:[0-9]{33}_)+|(?:[0-9]{34}_)+|(?:[0-9]{35}_)+|(?:[0-9]{36}_)+|(?:[0-9]{37}_)+|(?:[0-9]{38}_)+|(?:[0-9]{39}_)+|(?:[0-9]{40}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}}]}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,1}(?:_[0-9]{1})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"regex": "^[0-9_]*\\.[0-9]{2,5}(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,2}(?:_[0-9]{2})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"regex": "^[0-9_]*\\.[0-9]{3,5}(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,3}(?:_[0-9]{3})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"regex": "^[0-9_]*\\.[0-9]{4,5}(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,4}(?:_[0-9]{4})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"regex": "^[0-9_]*\\.[0-9]{5,5}(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^[0-9]{2,5}(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+[0-9]{1,1})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^[0-9]{3,5}(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{2}_)+[0-9]{1,2})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{2}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^[0-9]{4,5}(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{3}_)+[0-9]{1,3})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{3}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^[0-9]{5,5}(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{4}_)+[0-9]{1,4})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{4}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,1}(?:_[0-9]{1})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{2}_)+[0-9]{1,2}|(?:[0-9]{3}_)+[0-9]{1,3}|(?:[0-9]{4}_)+[0-9]{1,4})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{2}_)+|(?:[0-9]{3}_)+|(?:[0-9]{4}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,2}(?:_[0-9]{2})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+[0-9]{1,1}|(?:[0-9]{3}_)+[0-9]{1,3}|(?:[0-9]{4}_)+[0-9]{1,4})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+|(?:[0-9]{3}_)+|(?:[0-9]{4}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,3}(?:_[0-9]{3})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+[0-9]{1,1}|(?:[0-9]{2}_)+[0-9]{1,2}|(?:[0-9]{4}_)+[0-9]{1,4})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+|(?:[0-9]{2}_)+|(?:[0-9]{4}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,4}(?:_[0-9]{4})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+[0-9]{1,1}|(?:[0-9]{2}_)+[0-9]{1,2}|(?:[0-9]{3}_)+[0-9]{1,3})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{1}_)+|(?:[0-9]{2}_)+|(?:[0-9]{3}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}]}
+          ] }
+        ] }
+      ] } } },
+      "violation": {"suppress": {"clippy": {"lints": ["clippy::inconsistent_digit_grouping", "clippy::all", "clippy::style", "warnings"]}}, "anchor": "witness.span", "code": "inconsistent_digit_grouping", "message": "Regroup this literal's digits with underscores into equal-size groups, e.g. 1_000_000 instead of 1_0000_00."}
+    }
+  ]
+}

package/rules/clippy-int-plus-one.json

@@ -0,0 +1,36 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-int-plus-one",
+  "revision": 2,
+  "mode": "steer",
+  "description": "Use a strict comparison in Rust instead of a non-strict one that adds or subtracts one; it states the bound directly.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "ge-adjusted",
+      "forbid": { "ast": { "language": "rust", "rule": { "all": [
+        { "kind": "binary_expression" }, { "has": { "field": "operator", "regex": "^>=$" } },
+        { "any": [
+          { "has": { "field": "right", "kind": "binary_expression", "all": [ { "has": { "field": "operator", "regex": "^\\+$" } }, { "has": { "field": "right", "regex": "^1(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$" } } ] } },
+          { "has": { "field": "right", "kind": "binary_expression", "all": [ { "has": { "field": "operator", "regex": "^\\+$" } }, { "has": { "field": "left", "regex": "^1(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$" } } ] } },
+          { "has": { "field": "left", "kind": "binary_expression", "all": [ { "has": { "field": "operator", "regex": "^-$" } }, { "has": { "field": "right", "regex": "^1(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$" } } ] } },
+          { "has": { "field": "left", "kind": "binary_expression", "all": [ { "has": { "field": "operator", "regex": "^\\+$" } }, { "has": { "field": "left", "regex": "^-1(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$" } } ] } }
+        ] }
+      ] } } },
+      "violation": { "suppress": { "clippy": { "lints": ["clippy::int_plus_one", "clippy::all", "clippy::complexity", "warnings"] } }, "anchor": "witness.span", "code": "int_plus_one", "message": "Use > and drop the one here, e.g. x > y instead of x >= y + 1 or x - 1 >= y." }
+    },
+    {
+      "id": "le-adjusted",
+      "forbid": { "ast": { "language": "rust", "rule": { "all": [
+        { "kind": "binary_expression" }, { "has": { "field": "operator", "regex": "^<=$" } },
+        { "any": [
+          { "has": { "field": "left", "kind": "binary_expression", "all": [ { "has": { "field": "operator", "regex": "^\\+$" } }, { "has": { "field": "right", "regex": "^1(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$" } } ] } },
+          { "has": { "field": "left", "kind": "binary_expression", "all": [ { "has": { "field": "operator", "regex": "^\\+$" } }, { "has": { "field": "left", "regex": "^1(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$" } } ] } },
+          { "has": { "field": "right", "kind": "binary_expression", "all": [ { "has": { "field": "operator", "regex": "^-$" } }, { "has": { "field": "right", "regex": "^1(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$" } } ] } },
+          { "has": { "field": "right", "kind": "binary_expression", "all": [ { "has": { "field": "operator", "regex": "^\\+$" } }, { "has": { "field": "left", "regex": "^-1(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$" } } ] } }
+        ] }
+      ] } } },
+      "violation": { "suppress": { "clippy": { "lints": ["clippy::int_plus_one", "clippy::all", "clippy::complexity", "warnings"] } }, "anchor": "witness.span", "code": "int_plus_one", "message": "Use < and drop the one here, e.g. x < y instead of x + 1 <= y or x <= y - 1." }
+    }
+  ]
+}

package/rules/clippy-large-digit-groups.json

@@ -0,0 +1,28 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-large-digit-groups",
+  "revision": 2,
+  "mode": "steer",
+  "description": "Keep underscore-separated digit groups in Rust decimal literals to four digits or fewer; longer groups defeat the separators.",
+  "scope": {"include": ["**/*"], "exclude": []},
+  "clauses": [
+    {
+      "id": "large",
+      "forbid": { "ast": { "language": "rust", "rule": { "all": [
+        {"any": [{"kind": "integer_literal"}, {"kind": "float_literal"}]},
+        { "all": [
+          {"not": {"inside": {"stopBy": "end", "kind": "macro_definition"}}},
+          {"not": {"regex": "^[0-9][0-9_]*_(?:8|16|32|64)$"}},
+          {"not": {"regex": "^0[xbo][0-9A-Fa-f_]*_(?:8|16|32|64)$"}},
+          {"not": {"regex": "^[0-9_.]*[eE][+-]?[0-9_]*_(?:32|64)$"}},
+          {"not": {"regex": "^0x[0-9A-Fa-f]{8}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{12}(?:_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)))?$"}},
+          { "any": [
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,5}(?:_[0-9]{5})+|[0-9]{1,6}(?:_[0-9]{6})+|[0-9]{1,7}(?:_[0-9]{7})+|[0-9]{1,8}(?:_[0-9]{8})+|[0-9]{1,9}(?:_[0-9]{9})+|[0-9]{1,10}(?:_[0-9]{10})+|[0-9]{1,11}(?:_[0-9]{11})+|[0-9]{1,12}(?:_[0-9]{12})+|[0-9]{1,13}(?:_[0-9]{13})+|[0-9]{1,14}(?:_[0-9]{14})+|[0-9]{1,15}(?:_[0-9]{15})+|[0-9]{1,16}(?:_[0-9]{16})+|[0-9]{1,17}(?:_[0-9]{17})+|[0-9]{1,18}(?:_[0-9]{18})+|[0-9]{1,19}(?:_[0-9]{19})+|[0-9]{1,20}(?:_[0-9]{20})+|[0-9]{1,21}(?:_[0-9]{21})+|[0-9]{1,22}(?:_[0-9]{22})+|[0-9]{1,23}(?:_[0-9]{23})+|[0-9]{1,24}(?:_[0-9]{24})+|[0-9]{1,25}(?:_[0-9]{25})+|[0-9]{1,26}(?:_[0-9]{26})+|[0-9]{1,27}(?:_[0-9]{27})+|[0-9]{1,28}(?:_[0-9]{28})+|[0-9]{1,29}(?:_[0-9]{29})+|[0-9]{1,30}(?:_[0-9]{30})+|[0-9]{1,31}(?:_[0-9]{31})+|[0-9]{1,32}(?:_[0-9]{32})+|[0-9]{1,33}(?:_[0-9]{33})+|[0-9]{1,34}(?:_[0-9]{34})+|[0-9]{1,35}(?:_[0-9]{35})+|[0-9]{1,36}(?:_[0-9]{36})+|[0-9]{1,37}(?:_[0-9]{37})+|[0-9]{1,38}(?:_[0-9]{38})+|[0-9]{1,39}(?:_[0-9]{39})+|[0-9]{1,40}(?:_[0-9]{40})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]},
+            {"all": [{"regex": "^(?:[1-9].*|0|0[^xbo].*)$"}, {"regex": "^(?:[0-9]{1,5}|[0-9]{1,1}(?:_[0-9]{1})+|[0-9]{1,2}(?:_[0-9]{2})+|[0-9]{1,3}(?:_[0-9]{3})+|[0-9]{1,4}(?:_[0-9]{4})+)(?:\\..*|_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[^.]*\\..*$"}, {"any": [{"regex": "^[0-9_]*\\.(?:(?:[0-9]{5}_)+[0-9]{1,5}|(?:[0-9]{6}_)+[0-9]{1,6}|(?:[0-9]{7}_)+[0-9]{1,7}|(?:[0-9]{8}_)+[0-9]{1,8}|(?:[0-9]{9}_)+[0-9]{1,9}|(?:[0-9]{10}_)+[0-9]{1,10}|(?:[0-9]{11}_)+[0-9]{1,11}|(?:[0-9]{12}_)+[0-9]{1,12}|(?:[0-9]{13}_)+[0-9]{1,13}|(?:[0-9]{14}_)+[0-9]{1,14}|(?:[0-9]{15}_)+[0-9]{1,15}|(?:[0-9]{16}_)+[0-9]{1,16}|(?:[0-9]{17}_)+[0-9]{1,17}|(?:[0-9]{18}_)+[0-9]{1,18}|(?:[0-9]{19}_)+[0-9]{1,19}|(?:[0-9]{20}_)+[0-9]{1,20}|(?:[0-9]{21}_)+[0-9]{1,21}|(?:[0-9]{22}_)+[0-9]{1,22}|(?:[0-9]{23}_)+[0-9]{1,23}|(?:[0-9]{24}_)+[0-9]{1,24}|(?:[0-9]{25}_)+[0-9]{1,25}|(?:[0-9]{26}_)+[0-9]{1,26}|(?:[0-9]{27}_)+[0-9]{1,27}|(?:[0-9]{28}_)+[0-9]{1,28}|(?:[0-9]{29}_)+[0-9]{1,29}|(?:[0-9]{30}_)+[0-9]{1,30}|(?:[0-9]{31}_)+[0-9]{1,31}|(?:[0-9]{32}_)+[0-9]{1,32}|(?:[0-9]{33}_)+[0-9]{1,33}|(?:[0-9]{34}_)+[0-9]{1,34}|(?:[0-9]{35}_)+[0-9]{1,35}|(?:[0-9]{36}_)+[0-9]{1,36}|(?:[0-9]{37}_)+[0-9]{1,37}|(?:[0-9]{38}_)+[0-9]{1,38}|(?:[0-9]{39}_)+[0-9]{1,39}|(?:[0-9]{40}_)+[0-9]{1,40})(?:_?[eE].*|_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}, {"regex": "^[0-9_]*\\.(?:(?:[0-9]{5}_)+|(?:[0-9]{6}_)+|(?:[0-9]{7}_)+|(?:[0-9]{8}_)+|(?:[0-9]{9}_)+|(?:[0-9]{10}_)+|(?:[0-9]{11}_)+|(?:[0-9]{12}_)+|(?:[0-9]{13}_)+|(?:[0-9]{14}_)+|(?:[0-9]{15}_)+|(?:[0-9]{16}_)+|(?:[0-9]{17}_)+|(?:[0-9]{18}_)+|(?:[0-9]{19}_)+|(?:[0-9]{20}_)+|(?:[0-9]{21}_)+|(?:[0-9]{22}_)+|(?:[0-9]{23}_)+|(?:[0-9]{24}_)+|(?:[0-9]{25}_)+|(?:[0-9]{26}_)+|(?:[0-9]{27}_)+|(?:[0-9]{28}_)+|(?:[0-9]{29}_)+|(?:[0-9]{30}_)+|(?:[0-9]{31}_)+|(?:[0-9]{32}_)+|(?:[0-9]{33}_)+|(?:[0-9]{34}_)+|(?:[0-9]{35}_)+|(?:[0-9]{36}_)+|(?:[0-9]{37}_)+|(?:[0-9]{38}_)+|(?:[0-9]{39}_)+|(?:[0-9]{40}_)+)(?:_[eE].*|_(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)|(?:f32|f64))|)$"}]}]}
+          ] }
+        ] }
+      ] } } },
+      "violation": {"suppress": {"clippy": {"lints": ["clippy::large_digit_groups", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "large_digit_groups", "message": "Split this literal into digit groups of four or fewer, e.g. 1_000_000 instead of 1_000000."}
+    }
+  ]
+}

package/rules/clippy-many-single-char-names.json

@@ -0,0 +1,30 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-many-single-char-names",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Avoid more than four single-character variable names in scope at once in a Rust function, tests excluded; descriptive names are easier to follow.",
+  "scope": {"include": ["**/*"], "exclude": []},
+  "clauses": [
+    {
+      "id": "many-single-char-names",
+      "forbid": { "ast": { "language": "rust",
+        "utils": {
+          "counted": {"kind": "identifier", "regex": "^[^\\p{Lu}\\d_]$", "any": [{"binds": {"form": "parameter", "site": {"kind": "parameter"}}}, {"binds": {"form": "assignment", "site": {"kind": "let_declaration"}}}, {"binds": {"form": "match", "site": {"kind": "match_arm"}}}]},
+          "scope-node": {"any": [{"kind": "block", "not": {"inside": {"field": "body", "kind": "function_item"}}}, {"kind": "match_arm"}]},
+          "stack-before": {"params": ["T"], "rule": {"any": [{"binds": {"form": "parameter", "site": {"kind": "parameter"}}}, {"inside": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "kind": "let_declaration", "precedes": {"stopBy": "end", "any": [{"all": [{"pattern": "$S"}, {"compare": {"left": "S", "op": "eq", "right": "T", "text": "node"}}]}, {"has": {"stopBy": "end", "pattern": "$S", "all": [{"compare": {"left": "S", "op": "eq", "right": "T", "text": "node"}}]}}]}}}, {"inside": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "kind": "match_pattern", "inside": {"kind": "match_arm", "has": {"field": "value", "any": [{"all": [{"pattern": "$S"}, {"compare": {"left": "S", "op": "eq", "right": "T", "text": "node"}}]}, {"has": {"stopBy": "end", "pattern": "$S", "all": [{"compare": {"left": "S", "op": "eq", "right": "T", "text": "node"}}]}}]}}}}]}},
+          "fresh": {"all": [{"pattern": "$Y"}, {"not": {"binds": {"redefines": {}}}}, {"any": [{"not": {"inside": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "matches": "scope-node"}}}, {"inside": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "matches": "scope-node", "pattern": "$Z", "not": {"inside": {"stopBy": {"kind": "function_item"}, "kind": "function_item", "has": {"stopBy": {"kind": "function_item"}, "matches": "counted", "pattern": "$Y", "all": [{"matches": {"stack-before": {"T": "$Z"}}}]}}}}}]}]}
+        },
+        "rule": { "all": [
+          {"kind": "function_item"},
+          {"has": {"field": "body", "kind": "block"}},
+          {"count": {"has": {"stopBy": {"kind": "function_item"}, "kind": "identifier", "regex": "^[^\\p{Lu}\\d_]$"}, "min": 5}},
+          {"not": {"inside": {"kind": "declaration_list", "inside": {"kind": "trait_item"}}}},
+          {"not": {"follows": {"stopBy": {"not": {"any": [{"kind": "attribute_item"}, {"kind": "line_comment"}, {"kind": "block_comment"}]}}, "kind": "attribute_item", "regex": "^#\\[\\s*test\\s*\\]$"}}},
+          {"has": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "matches": "counted", "pattern": "$B"}},
+          {"any": [{"count": {"has": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "matches": "counted", "all": [{"not": {"binds": {"redefines": {}}}}]}, "min": 5}}, {"has": {"stopBy": {"kind": "function_item"}, "matches": "scope-node", "pattern": "$SC", "all": [{"has": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "kind": "identifier", "regex": "^[^\\p{Lu}\\d_]$", "matches": "counted"}}, {"inside": {"stopBy": {"kind": "function_item"}, "kind": "function_item", "has": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "pattern": "$B", "all": [{"matches": {"stack-before": {"T": "$SC"}}}]}}}, {"any": [{"all": [{"count": {"has": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "matches": "counted", "all": [{"matches": "fresh"}]}, "min": 1}}, {"inside": {"stopBy": {"kind": "function_item"}, "kind": "function_item", "count": {"has": {"stopBy": {"kind": "function_item"}, "matches": "counted", "all": [{"matches": {"stack-before": {"T": "$SC"}}}, {"matches": "fresh"}]}, "min": 4}}}]}, {"all": [{"count": {"has": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "matches": "counted", "all": [{"matches": "fresh"}]}, "min": 2}}, {"inside": {"stopBy": {"kind": "function_item"}, "kind": "function_item", "count": {"has": {"stopBy": {"kind": "function_item"}, "matches": "counted", "all": [{"matches": {"stack-before": {"T": "$SC"}}}, {"matches": "fresh"}]}, "min": 3}}}]}, {"all": [{"count": {"has": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "matches": "counted", "all": [{"matches": "fresh"}]}, "min": 3}}, {"inside": {"stopBy": {"kind": "function_item"}, "kind": "function_item", "count": {"has": {"stopBy": {"kind": "function_item"}, "matches": "counted", "all": [{"matches": {"stack-before": {"T": "$SC"}}}, {"matches": "fresh"}]}, "min": 2}}}]}, {"all": [{"count": {"has": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "matches": "counted", "all": [{"matches": "fresh"}]}, "min": 4}}, {"inside": {"stopBy": {"kind": "function_item"}, "kind": "function_item", "count": {"has": {"stopBy": {"kind": "function_item"}, "matches": "counted", "all": [{"matches": {"stack-before": {"T": "$SC"}}}, {"matches": "fresh"}]}, "min": 1}}}]}, {"all": [{"count": {"has": {"stopBy": {"any": [{"matches": "scope-node"}, {"kind": "function_item"}]}, "matches": "counted", "all": [{"matches": "fresh"}]}, "min": 5}}]}]}]}}]}
+        ] } } },
+      "violation": {"suppress": {"clippy": {"lints": ["clippy::many_single_char_names", "clippy::pedantic", "warnings"]}}, "anchor": "capture.B", "code": "many_single_char_names", "message": "Rename some of these single-letter variables to descriptive names; more than four are in scope here."}
+    }
+  ]
+}

package/rules/clippy-mixed-case-hex-literals.json

@@ -0,0 +1 @@
+{"format":"rerail.policy/v1","id":"clippy-mixed-case-hex-literals","revision":2,"mode":"steer","description":"Use one letter case for the digits of a Rust hexadecimal literal, all upper or all lower.","scope":{"include":["**/*"],"exclude":[]},"clauses":[{"id":"mixed-case-hex-literals","forbid":{"ast":{"language":"rust","rule":{"all":[{"kind":"integer_literal"},{"regex":"^0x[0-9A-Fa-f_]+(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$"},{"regex":"^0x[0-9A-Fa-f_]*[a-f]"},{"regex":"^0x[0-9A-Fa-f_]*[A-F]"}]}}},"violation":{"suppress":{"clippy":{"lints":["clippy::mixed_case_hex_literals","clippy::all","clippy::style","warnings"]}},"anchor":"witness.span","code":"mixed_case_hex_literals","message":"Use one letter case for this hex literal's digits, e.g. 0xABCD or 0xabcd, not 0xAbCd."}}]}

package/rules/clippy-needless-arbitrary-self-type.json

@@ -0,0 +1,12 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-needless-arbitrary-self-type",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Write a Rust method receiver as self, &self or &mut self instead of spelling out its Self type.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    { "id": "self-explicit-self", "forbid": { "ast": { "language": "rust", "rule": { "kind": "parameter", "regex": "^(mut )?self: ?Self$" } } }, "violation": { "suppress": { "clippy": { "lints": ["clippy::needless_arbitrary_self_type", "clippy::all", "clippy::complexity", "warnings"] } }, "anchor": "witness.span", "code": "needless_arbitrary_self_type", "message": "Write this receiver as self or mut self instead of self: Self." } },
+    { "id": "self-explicit-reference", "forbid": { "ast": { "language": "rust", "rule": { "kind": "parameter", "regex": "^self: &[^&]*Self$" } } }, "violation": { "suppress": { "clippy": { "lints": ["clippy::needless_arbitrary_self_type", "clippy::all", "clippy::complexity", "warnings"] } }, "anchor": "witness.span", "code": "needless_arbitrary_self_type", "message": "Write this receiver in short form, e.g. &self or &'a mut self instead of self: &'a mut Self." } }
+  ]
+}

package/rules/clippy-needless-else.json

@@ -0,0 +1,15 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-needless-else",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Remove empty else blocks, with no code or comment, from Rust if statements.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "empty-else-block",
+      "forbid": { "ast": { "language": "rust", "rule": { "kind": "else_clause", "has": { "kind": "block", "regex": "^\\{\\s*\\}$" }, "not": { "regex": "(?s)/\\*|//" } } } },
+      "violation": { "suppress": { "clippy": { "lints": ["clippy::needless_else", "clippy::all", "clippy::style", "warnings"] } }, "anchor": "witness.span", "code": "needless_else", "message": "Remove this empty else block." }
+    }
+  ]
+}

package/rules/clippy-needless-raw-string-hashes.json

@@ -0,0 +1,20 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-needless-raw-string-hashes",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Use no more hashes on a Rust raw string literal than its contents need to close it.",
+  "scope": {"include": ["**/*"], "exclude": []},
+  "clauses": [
+    {"id": "hashes-1", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r#\"(?s:.*)\"#$"}, {"regex": "^(?:b|c)?r#\"(?s:.*)[\\\\\"](?s:.*)\"#$"}, {"not": {"regex": "^(?:b|c)?r#\"(?s:.*)\"(?s:.*)\"#$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}},
+    {"id": "hashes-2", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r##\"(?s:.*)\"##$"}, {"regex": "^(?:b|c)?r##\"(?s:.*)[\\\\\"](?s:.*)\"##$"}, {"not": {"regex": "^(?:b|c)?r##\"(?:[^\"]|\"#*(?:\"|[^\"#]))*\"#(?s:.*)\"##$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}},
+    {"id": "hashes-3", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r###\"(?s:.*)\"###$"}, {"regex": "^(?:b|c)?r###\"(?s:.*)[\\\\\"](?s:.*)\"###$"}, {"not": {"regex": "^(?:b|c)?r###\"(?:[^\"]|\"#*(?:\"|[^\"#]))*\"##(?s:.*)\"###$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}},
+    {"id": "hashes-4", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r####\"(?s:.*)\"####$"}, {"regex": "^(?:b|c)?r####\"(?s:.*)[\\\\\"](?s:.*)\"####$"}, {"not": {"regex": "^(?:b|c)?r####\"(?:[^\"]|\"#*(?:\"|[^\"#]))*\"###(?s:.*)\"####$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}},
+    {"id": "hashes-5", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r#####\"(?s:.*)\"#####$"}, {"regex": "^(?:b|c)?r#####\"(?s:.*)[\\\\\"](?s:.*)\"#####$"}, {"not": {"regex": "^(?:b|c)?r#####\"(?:[^\"]|\"#*(?:\"|[^\"#]))*\"####(?s:.*)\"#####$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}},
+    {"id": "hashes-6", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r######\"(?s:.*)\"######$"}, {"regex": "^(?:b|c)?r######\"(?s:.*)[\\\\\"](?s:.*)\"######$"}, {"not": {"regex": "^(?:b|c)?r######\"(?:[^\"]|\"#*(?:\"|[^\"#]))*\"#####(?s:.*)\"######$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}},
+    {"id": "hashes-7", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r#######\"(?s:.*)\"#######$"}, {"regex": "^(?:b|c)?r#######\"(?s:.*)[\\\\\"](?s:.*)\"#######$"}, {"not": {"regex": "^(?:b|c)?r#######\"(?:[^\"]|\"#*(?:\"|[^\"#]))*\"######(?s:.*)\"#######$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}},
+    {"id": "hashes-8", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r########\"(?s:.*)\"########$"}, {"regex": "^(?:b|c)?r########\"(?s:.*)[\\\\\"](?s:.*)\"########$"}, {"not": {"regex": "^(?:b|c)?r########\"(?:[^\"]|\"#*(?:\"|[^\"#]))*\"#######(?s:.*)\"########$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}},
+    {"id": "hashes-9", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r#########\"(?s:.*)\"#########$"}, {"regex": "^(?:b|c)?r#########\"(?s:.*)[\\\\\"](?s:.*)\"#########$"}, {"not": {"regex": "^(?:b|c)?r#########\"(?:[^\"]|\"#*(?:\"|[^\"#]))*\"########(?s:.*)\"#########$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}},
+    {"id": "hashes-10", "forbid": {"ast": {"language": "rust", "rule": {"all": [{"kind": "raw_string_literal"}, {"regex": "^(?:b|c)?r##########\"(?s:.*)\"##########$"}, {"regex": "^(?:b|c)?r##########\"(?s:.*)[\\\\\"](?s:.*)\"##########$"}, {"not": {"regex": "^(?:b|c)?r##########\"(?:[^\"]|\"#*(?:\"|[^\"#]))*\"#########(?s:.*)\"##########$"}}]}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::needless_raw_string_hashes", "clippy::pedantic", "warnings"]}}, "anchor": "witness.span", "code": "needless_raw_string_hashes", "message": "Remove the extra # marks from this raw string, keeping only as many as its contents need to close it."}}
+  ]
+}

package/rules/clippy-octal-escapes.json

@@ -0,0 +1,24 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-octal-escapes",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Avoid a null escape followed by digits in Rust string literals; Rust has no octal escapes, so it yields a NUL then digits, not the intended character.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [{
+    "id": "octal-escape",
+    "forbid": { "ast": { "language": "rust", "rule": {
+      "kind": "string_literal",
+      "regex": "(?s)(?:^|[^\\\\]|\\\\\\\\)(?P<O>\\\\0[0-7]{1,2})"
+    } } },
+    "violation": { "suppress": { "clippy": { "lints": ["clippy::octal_escapes", "clippy::all", "clippy::suspicious", "warnings"] } }, "anchor": "capture.O", "code": "octal_escapes", "message": "Replace this \\0 escape with the intended character, e.g. \\x1b for \\033, or \\x00 then the digits if NUL was meant." }
+  }, {
+    "id": "octal-escape-after-first",
+      "forbid": { "ast": { "language": "rust", "rule": {
+        "kind": "string_literal",
+        "regex": "(?s).*?(?:^|[^\\\\]|\\\\\\\\)\\\\0[0-7]{1,2}.*?(?P<O>\\\\0[0-7]{1,2})"
+      } } },
+      "violation": { "suppress": { "clippy": { "lints": ["clippy::octal_escapes", "clippy::all", "clippy::suspicious", "warnings"] } }, "anchor": "capture.O", "code": "octal_escapes", "message": "Replace this \\0 escape with the intended character, e.g. \\x1b for \\033, or \\x00 then the digits if NUL was meant." }
+  }
+  ]
+}

package/rules/clippy-partial-pub-fields.json

@@ -0,0 +1,50 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-partial-pub-fields",
+  "revision": 2,
+  "mode": "steer",
+  "description": "Make a Rust struct's fields either all pub or all non-pub; mixing them blurs what the type exposes.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "shared",
+      "define": { "language": "rust", "utils": {
+        "pub-field": { "has": { "kind": "visibility_modifier", "regex": "^pub$" } },
+        "later-field": { "kind": "field_declaration", "inside": { "kind": "field_declaration_list", "inside": { "kind": "struct_item" } }, "follows": { "stopBy": "end", "kind": "field_declaration" } },
+        "first-pub-after-private": { "matches": "later-field", "all": [{ "matches": "pub-field" }, { "not": { "follows": { "stopBy": "end", "kind": "field_declaration", "matches": "pub-field" } } }] },
+        "first-private-after-pub": { "matches": "later-field", "all": [{ "not": { "matches": "pub-field" } }, { "not": { "follows": { "stopBy": "end", "kind": "field_declaration", "not": { "matches": "pub-field" } } } }] },
+        "skipped": { "any": [{ "kind": "attribute_item" }, { "kind": "line_comment" }, { "kind": "block_comment" }] },
+        "tuple-field": {
+          "inside": { "kind": "ordered_field_declaration_list", "inside": { "kind": "struct_item" } },
+          "follows": { "stopBy": { "not": { "any": [{ "matches": "skipped" }, { "kind": "visibility_modifier" }] } }, "regex": "^[(,]$" },
+          "not": { "any": [{ "matches": "skipped" }, { "kind": "visibility_modifier" }, { "regex": "^[(),]$" }] }
+        },
+        "tuple-vis": { "follows": { "stopBy": { "not": { "matches": "skipped" } }, "kind": "visibility_modifier" } },
+        "tuple-pub": { "follows": { "stopBy": { "not": { "matches": "skipped" } }, "kind": "visibility_modifier", "regex": "^pub$" } },
+        "tuple-first-private-after-pub": { "all": [
+          { "matches": "tuple-field" },
+          { "not": { "matches": "tuple-pub" } },
+          { "follows": { "stopBy": "end", "regex": "^,$" } },
+          { "not": { "follows": { "stopBy": "end", "matches": "tuple-field", "not": { "matches": "tuple-pub" } } } }
+        ] }
+      } }
+    },
+    {
+      "id": "field-visibility",
+      "forbid": { "ast": { "language": "rust", "rule": { "kind": "visibility_modifier", "any": [
+        { "inside": { "stopBy": "neighbor", "any": [{ "matches": "first-pub-after-private" }, { "matches": "first-private-after-pub" }] } },
+        { "regex": "^pub$", "inside": { "kind": "ordered_field_declaration_list", "inside": { "kind": "struct_item" } }, "follows": { "stopBy": "end", "regex": "^,$" }, "not": { "follows": { "stopBy": "end", "kind": "visibility_modifier", "regex": "^pub$" } } },
+        { "precedes": { "stopBy": { "not": { "matches": "skipped" } }, "matches": "tuple-first-private-after-pub" } }
+      ] } } },
+      "violation": { "suppress": { "clippy": { "lints": ["clippy::partial_pub_fields", "clippy::restriction", "warnings"] } }, "anchor": "witness.span", "code": "partial_pub_fields", "message": "Match this field's visibility to the struct's other fields: make all of them pub or none of them." }
+    },
+    {
+      "id": "inherited-visibility-after-pub",
+      "forbid": { "ast": { "language": "rust", "rule": { "any": [
+        { "matches": "first-private-after-pub", "not": { "has": { "kind": "visibility_modifier" } } },
+        { "matches": "tuple-first-private-after-pub", "not": { "matches": "tuple-vis" } }
+      ] } } },
+      "violation": { "suppress": { "clippy": { "lints": ["clippy::partial_pub_fields", "clippy::restriction", "warnings"] } }, "anchor": "witness.start", "code": "partial_pub_fields", "message": "Match this field's visibility to the struct's other fields: make all of them pub or none of them." }
+    }
+  ]
+}

package/rules/clippy-precedence-bits.json

@@ -0,0 +1,105 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-precedence-bits",
+  "revision": 4,
+  "mode": "steer",
+  "description": "Parenthesize shifts used as operands of a bitwise AND, OR or XOR in Rust; the precedence is easy to misread.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "bitwise-with-shift",
+      "forbid": {
+        "ast": {
+          "language": "rust",
+          "rule": {
+            "matches": "lint"
+          },
+          "utils": {
+            "lint": {
+              "all": [
+                {
+                  "kind": "binary_expression"
+                },
+                {
+                  "has": {
+                    "field": "operator",
+                    "regex": "^[&^|]$"
+                  }
+                },
+                {
+                  "any": [
+                    {
+                      "has": {
+                        "field": "left",
+                        "kind": "binary_expression",
+                        "has": {
+                          "field": "operator",
+                          "regex": "^(?:<<|>>)$"
+                        }
+                      }
+                    },
+                    {
+                      "has": {
+                        "field": "right",
+                        "kind": "binary_expression",
+                        "has": {
+                          "field": "operator",
+                          "regex": "^(?:<<|>>)$"
+                        }
+                      }
+                    }
+                  ]
+                },
+                {
+                  "not": {
+                    "any": [
+                      {
+                        "has": {
+                          "field": "left",
+                          "kind": "binary_expression",
+                          "has": {
+                            "field": "operator",
+                            "regex": "^[-+*/%]$"
+                          }
+                        }
+                      },
+                      {
+                        "has": {
+                          "field": "right",
+                          "kind": "binary_expression",
+                          "has": {
+                            "field": "operator",
+                            "regex": "^[-+*/%]$"
+                          }
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          }
+        }
+      },
+      "violation": {
+        "suppress": {
+          "clippy": {
+            "lints": [
+              "clippy::precedence_bits",
+              "clippy::restriction",
+              "warnings"
+            ]
+          }
+        },
+        "anchor": "witness.span",
+        "code": "precedence_bits",
+        "message": "Add parentheses around the shift in this bitwise expression, e.g. (a << 4) | b."
+      }
+    }
+  ]
+}

package/rules/clippy-precedence.json

@@ -0,0 +1,25 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-precedence",
+  "revision": 3,
+  "mode": "steer",
+  "description": "Parenthesize arithmetic used as an operand of a shift or bitwise operator in Rust; the precedence is easy to misread.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "shift-with-arithmetic",
+      "forbid": { "ast": { "language": "rust", "rule": { "kind": "binary_expression", "has": { "field": "operator", "regex": "^(?:<<|>>)$" }, "any": [ { "has": { "field": "left", "kind": "binary_expression", "has": { "field": "operator", "regex": "^[-+*/%]$" } } }, { "has": { "field": "right", "kind": "binary_expression", "has": { "field": "operator", "regex": "^[-+*/%]$" } } } ] } } },
+      "violation": { "suppress": { "clippy": { "lints": ["clippy::precedence", "clippy::all", "clippy::complexity", "warnings"] } }, "anchor": "witness.span", "code": "precedence", "message": "Add parentheses around the arithmetic in this shift, e.g. (a + b) << c, to make the order explicit." }
+    },
+    {
+      "id": "bitwise-with-arithmetic",
+      "forbid": { "ast": { "language": "rust", "rule": { "kind": "binary_expression", "has": { "field": "operator", "regex": "^[&^|]$" }, "any": [ { "has": { "field": "left", "kind": "binary_expression", "has": { "field": "operator", "regex": "^[-+*/%]$" } } }, { "has": { "field": "right", "kind": "binary_expression", "has": { "field": "operator", "regex": "^[-+*/%]$" } } } ] } } },
+      "violation": { "suppress": { "clippy": { "lints": ["clippy::precedence", "clippy::all", "clippy::complexity", "warnings"] } }, "anchor": "witness.span", "code": "precedence", "message": "Add parentheses around the arithmetic in this bitwise expression, e.g. (a + b) & mask, to make the order explicit." }
+    },
+    {
+      "id": "closure-block-call",
+      "forbid": { "ast": { "language": "rust", "rule": { "kind": "call_expression", "has": { "field": "function", "kind": "field_expression", "has": { "field": "value", "kind": "closure_expression" } } } } },
+      "violation": { "suppress": { "clippy": { "lints": ["clippy::precedence", "clippy::all", "clippy::complexity", "warnings"] } }, "anchor": "witness.span", "code": "precedence", "message": "Wrap this closure in parentheses so it's clear the method call applies to the closure, not its body." }
+    }
+  ]
+}

package/rules/clippy-redundant-at-rest-pattern.json

@@ -0,0 +1,11 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-redundant-at-rest-pattern",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Bind a whole Rust slice directly instead of through a slice pattern holding only a rest binding.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    { "id": "redundant-slice-rest-binding", "forbid": { "ast": { "language": "rust", "rule": { "kind": "slice_pattern", "regex": "(?s)^\\[\\s*(?:(?:ref\\s+mut|ref|mut)\\s+)?[A-Za-z_][A-Za-z0-9_]*\\s*@\\s*\\.\\.\\s*\\]$" } } }, "violation": { "suppress": { "clippy": { "lints": ["clippy::redundant_at_rest_pattern", "clippy::all", "clippy::complexity", "warnings"] } }, "anchor": "witness.span", "code": "redundant_at_rest_pattern", "message": "Bind the whole slice directly, e.g. rest instead of [rest @ ..]." } }
+  ]
+}

package/rules/clippy-single-component-path-imports.json

@@ -0,0 +1,36 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-single-component-path-imports",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Remove private imports of a bare crate name in Rust 2018 and later; the crate is already in scope without them.",
+  "scope": {"include": ["**/*"], "exclude": []},
+  "clauses": [
+    {
+      "id": "single-component-import",
+      "forbid": { "ast": { "language": "rust",
+        "utils": {
+          "module-item": {"inside": {"any": [{"kind": "source_file"}, {"kind": "declaration_list", "inside": {"kind": "mod_item"}}]}},
+          "not-pub": {"not": {"has": {"kind": "visibility_modifier", "regex": "^pub$"}}},
+          "starts-with-n": {"any": [{"kind": "identifier", "pattern": "$N"}, {"has": {"field": "path", "matches": "starts-with-n"}}, {"kind": "use_wildcard", "has": {"matches": "starts-with-n"}}]},
+          "self-n": {"kind": "scoped_identifier", "has": {"field": "path", "kind": "self"}, "all": [{"has": {"field": "name", "pattern": "$N"}}]},
+          "reused-with-self": {"any": [{"follows": {"stopBy": "end", "kind": "use_declaration", "matches": "not-pub", "has": {"stopBy": "end", "any": [{"matches": "self-n"}, {"kind": "scoped_use_list", "has": {"field": "path", "kind": "self"}, "all": [{"has": {"field": "list", "has": {"matches": "starts-with-n"}}}]}]}}}, {"precedes": {"stopBy": "end", "kind": "use_declaration", "matches": "not-pub", "has": {"stopBy": "end", "any": [{"matches": "self-n"}, {"kind": "scoped_use_list", "has": {"field": "path", "kind": "self"}, "all": [{"has": {"field": "list", "has": {"matches": "starts-with-n"}}}]}]}}}, {"inside": {"any": [{"kind": "source_file"}, {"kind": "declaration_list"}], "has": {"stopBy": "end", "matches": "self-n", "not": {"inside": {"stopBy": "end", "kind": "use_declaration"}}}}}, {"follows": {"stopBy": "end", "kind": "macro_definition", "has": {"field": "name", "pattern": "$N"}}}]}
+        },
+        "rule": {"all": [{"kind": "use_declaration"}, {"has": {"field": "argument", "kind": "identifier", "pattern": "$N"}}, {"matches": "module-item"}, {"matches": "not-pub"}, {"not": {"matches": "reused-with-self"}}]} } },
+      "violation": {"suppress": {"clippy": {"lints": ["clippy::single_component_path_imports", "clippy::all", "clippy::style", "warnings"]}}, "anchor": "witness.span", "code": "single_component_path_imports", "message": "Remove this use of a bare crate name; the crate is already in scope."}
+    },
+    {
+      "id": "nested-single-component-import",
+      "forbid": { "ast": { "language": "rust",
+        "utils": {
+          "module-item": {"inside": {"any": [{"kind": "source_file"}, {"kind": "declaration_list", "inside": {"kind": "mod_item"}}]}},
+          "not-pub": {"not": {"has": {"kind": "visibility_modifier", "regex": "^pub$"}}},
+          "starts-with-n": {"any": [{"kind": "identifier", "pattern": "$N"}, {"has": {"field": "path", "matches": "starts-with-n"}}, {"kind": "use_wildcard", "has": {"matches": "starts-with-n"}}]},
+          "self-n": {"kind": "scoped_identifier", "has": {"field": "path", "kind": "self"}, "all": [{"has": {"field": "name", "pattern": "$N"}}]},
+          "reused-with-self": {"any": [{"follows": {"stopBy": "end", "kind": "use_declaration", "matches": "not-pub", "has": {"stopBy": "end", "any": [{"matches": "self-n"}, {"kind": "scoped_use_list", "has": {"field": "path", "kind": "self"}, "all": [{"has": {"field": "list", "has": {"matches": "starts-with-n"}}}]}]}}}, {"precedes": {"stopBy": "end", "kind": "use_declaration", "matches": "not-pub", "has": {"stopBy": "end", "any": [{"matches": "self-n"}, {"kind": "scoped_use_list", "has": {"field": "path", "kind": "self"}, "all": [{"has": {"field": "list", "has": {"matches": "starts-with-n"}}}]}]}}}, {"inside": {"any": [{"kind": "source_file"}, {"kind": "declaration_list"}], "has": {"stopBy": "end", "matches": "self-n", "not": {"inside": {"stopBy": "end", "kind": "use_declaration"}}}}}, {"follows": {"stopBy": "end", "kind": "macro_definition", "has": {"field": "name", "pattern": "$N"}}}]}
+        },
+        "rule": {"all": [{"kind": "identifier", "pattern": "$N"}, {"inside": {"kind": "use_list", "inside": {"field": "argument", "kind": "use_declaration", "matches": "module-item", "all": [{"matches": "not-pub"}, {"not": {"matches": "reused-with-self"}}]}}}]} } },
+      "violation": {"suppress": {"clippy": {"lints": ["clippy::single_component_path_imports", "clippy::all", "clippy::style", "warnings"]}}, "anchor": "witness.span", "code": "single_component_path_imports", "message": "Remove this bare crate name from the use list; the crate is already in scope."}
+    }
+  ]
+}

package/rules/clippy-unneeded-wildcard-pattern.json

@@ -0,0 +1,18 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-unneeded-wildcard-pattern",
+  "revision": 2,
+  "mode": "steer",
+  "description": "Remove wildcard patterns next to a rest pattern in Rust; the rest pattern already ignores those elements.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {"id": "wildcards-before-rest", "forbid": {"ast": {"language": "rust", "rule": {"any": [{"kind": "tuple_pattern"}, {"kind": "tuple_struct_pattern"}], "regex": "(?s)^[^(]*\\((?:(?:[^()\\[\\]{}\"',]|\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)'|[(\\[{](?:[^()\\[\\]{}\"']|\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)'|[(\\[{](?:[^()\\[\\]{}\"']|\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)')*[)\\]}])*[)\\]}])*,)*?\\s*(?P<W>(?:_\\s*,\\s*)+)\\.\\.\\s*[,)]"}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::unneeded_wildcard_pattern", "clippy::all", "clippy::complexity", "warnings"]}}, "anchor": "capture.W", "code": "unneeded_wildcard_pattern", "message": "Remove the _ wildcards before this ..; the rest pattern already skips them."}},
+    {"id": "wildcards-after-rest", "forbid": {"ast": {"language": "rust", "rule": {"any": [{"kind": "tuple_pattern"}, {"kind": "tuple_struct_pattern"}], "regex": "(?s)^[^(]*\\((?:(?:[^()\\[\\]{}\"',]|\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)'|[(\\[{](?:[^()\\[\\]{}\"']|\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)'|[(\\[{](?:[^()\\[\\]{}\"']|\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)')*[)\\]}])*[)\\]}])*,)*?\\s*\\.\\.(?P<W>(?:\\s*,\\s*_)+)\\s*[,)]"}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::unneeded_wildcard_pattern", "clippy::all", "clippy::complexity", "warnings"]}}, "anchor": "capture.W", "code": "unneeded_wildcard_pattern", "message": "Remove the _ wildcards after this ..; the rest pattern already skips them."}},
+    {"id": "struct-wildcard-fields-before-rest", "forbid": {"ast": {"language": "rust", "rule": {"kind": "struct_pattern", "regex": "(?s)^[^{]*\\{(?:(?:[^()\\[\\]{}\"',]|\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)'|[(\\[{](?:[^()\\[\\]{}\"']|\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)'|[(\\[{](?:[^()\\[\\]{}\"']|\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)')*[)\\]}])*[)\\]}])*,)*?\\s*(?P<W>(?:[\\w#]+\\s*:\\s*_\\s*,\\s*)+)\\.\\.\\s*\\}"}}}, "violation": {"suppress": {"clippy": {"lints": ["clippy::unneeded_wildcard_pattern", "clippy::all", "clippy::complexity", "warnings"]}}, "anchor": "capture.W", "code": "unneeded_wildcard_pattern", "message": "Remove the field: _ entries before this ..; the rest pattern already skips those fields."}}
+  ]
+}

package/rules/clippy-unusual-byte-groupings.json

@@ -0,0 +1,27 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "clippy-unusual-byte-groupings",
+  "revision": 2,
+  "mode": "steer",
+  "description": "Split Rust binary, octal and hexadecimal literals into equal-size digit groups; uneven groups hide the bit layout.",
+  "scope": {"include": ["**/*"], "exclude": []},
+  "clauses": [
+    {
+      "id": "unusual",
+      "forbid": { "ast": { "language": "rust", "rule": { "all": [
+        {"any": [{"kind": "integer_literal"}, {"kind": "float_literal"}]},
+        { "all": [
+          {"not": {"inside": {"stopBy": "end", "kind": "macro_definition"}}},
+          {"not": {"regex": "^[0-9][0-9_]*_(?:8|16|32|64)$"}},
+          {"not": {"regex": "^0[xbo][0-9A-Fa-f_]*_(?:8|16|32|64)$"}},
+          {"not": {"regex": "^[0-9_.]*[eE][+-]?[0-9_]*_(?:32|64)$"}},
+          {"not": {"regex": "^0x[0-9A-Fa-f]{8}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{12}(?:_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)))?$"}},
+          { "any": [
+            {"all": [{"regex": "^0[xbo].*$"}, {"not": {"regex": "^0[xbo][0-9A-Fa-f]+(?:_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)))?$"}}, {"not": {"regex": "^0[xbo](?:[0-9A-Fa-f]{0,1}(?:_[0-9A-Fa-f]{1})+|[0-9A-Fa-f]{0,2}(?:_[0-9A-Fa-f]{2})+|[0-9A-Fa-f]{0,3}(?:_[0-9A-Fa-f]{3})+|[0-9A-Fa-f]{0,4}(?:_[0-9A-Fa-f]{4})+|[0-9A-Fa-f]{0,5}(?:_[0-9A-Fa-f]{5})+|[0-9A-Fa-f]{0,6}(?:_[0-9A-Fa-f]{6})+|[0-9A-Fa-f]{0,7}(?:_[0-9A-Fa-f]{7})+|[0-9A-Fa-f]{0,8}(?:_[0-9A-Fa-f]{8})+|[0-9A-Fa-f]{0,9}(?:_[0-9A-Fa-f]{9})+|[0-9A-Fa-f]{0,10}(?:_[0-9A-Fa-f]{10})+|[0-9A-Fa-f]{0,11}(?:_[0-9A-Fa-f]{11})+|[0-9A-Fa-f]{0,12}(?:_[0-9A-Fa-f]{12})+|[0-9A-Fa-f]{0,13}(?:_[0-9A-Fa-f]{13})+|[0-9A-Fa-f]{0,14}(?:_[0-9A-Fa-f]{14})+|[0-9A-Fa-f]{0,15}(?:_[0-9A-Fa-f]{15})+|[0-9A-Fa-f]{0,16}(?:_[0-9A-Fa-f]{16})+|[0-9A-Fa-f]{0,17}(?:_[0-9A-Fa-f]{17})+|[0-9A-Fa-f]{0,18}(?:_[0-9A-Fa-f]{18})+|[0-9A-Fa-f]{0,19}(?:_[0-9A-Fa-f]{19})+|[0-9A-Fa-f]{0,20}(?:_[0-9A-Fa-f]{20})+|[0-9A-Fa-f]{0,21}(?:_[0-9A-Fa-f]{21})+|[0-9A-Fa-f]{0,22}(?:_[0-9A-Fa-f]{22})+|[0-9A-Fa-f]{0,23}(?:_[0-9A-Fa-f]{23})+|[0-9A-Fa-f]{0,24}(?:_[0-9A-Fa-f]{24})+|[0-9A-Fa-f]{0,25}(?:_[0-9A-Fa-f]{25})+|[0-9A-Fa-f]{0,26}(?:_[0-9A-Fa-f]{26})+|[0-9A-Fa-f]{0,27}(?:_[0-9A-Fa-f]{27})+|[0-9A-Fa-f]{0,28}(?:_[0-9A-Fa-f]{28})+|[0-9A-Fa-f]{0,29}(?:_[0-9A-Fa-f]{29})+|[0-9A-Fa-f]{0,30}(?:_[0-9A-Fa-f]{30})+|[0-9A-Fa-f]{0,31}(?:_[0-9A-Fa-f]{31})+|[0-9A-Fa-f]{0,32}(?:_[0-9A-Fa-f]{32})+|[0-9A-Fa-f]{0,33}(?:_[0-9A-Fa-f]{33})+|[0-9A-Fa-f]{0,34}(?:_[0-9A-Fa-f]{34})+|[0-9A-Fa-f]{0,35}(?:_[0-9A-Fa-f]{35})+|[0-9A-Fa-f]{0,36}(?:_[0-9A-Fa-f]{36})+|[0-9A-Fa-f]{0,37}(?:_[0-9A-Fa-f]{37})+|[0-9A-Fa-f]{0,38}(?:_[0-9A-Fa-f]{38})+|[0-9A-Fa-f]{0,39}(?:_[0-9A-Fa-f]{39})+|[0-9A-Fa-f]{0,40}(?:_[0-9A-Fa-f]{40})+)(?:_?(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)))?$"}}]}
+          ] }
+        ] }
+      ] } } },
+      "violation": {"suppress": {"clippy": {"lints": ["clippy::unusual_byte_groupings", "clippy::all", "clippy::style", "warnings"]}}, "anchor": "witness.span", "code": "unusual_byte_groupings", "message": "Regroup this literal's digits into equal-size groups, e.g. 0xFFFF_FFFF or 0b1010_1010."}
+    }
+  ]
+}

package/rules/clippy-zero-prefixed-literal.json

@@ -0,0 +1 @@
+{"format":"rerail.policy/v1","id":"clippy-zero-prefixed-literal","revision":2,"mode":"steer","description":"Avoid leading zeros on Rust decimal literals; Rust doesn't read them as octal, so use an explicit octal prefix or drop the zero.","scope":{"include":["**/*"],"exclude":[]},"clauses":[{"id":"zero-prefixed-literal","forbid":{"ast":{"language":"rust","rule":{"kind":"integer_literal","regex":"^0(?:[0-9]|_[0-9])[0-9_]*(?:(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize))?$"}}},"violation":{"suppress":{"clippy":{"lints":["clippy::zero_prefixed_literal","clippy::all","clippy::complexity","warnings"]}},"anchor":"witness.span","code":"zero_prefixed_literal","message":"Drop the leading zero from this literal, or use the 0o prefix if you meant octal."}}]}