Rules Correctness - float-equality-without-abs — Require an absolute difference in Number.EPSILON comparisons - for-direction — Disallow for loops whose counter moves away from its bound - imprecise-float-operation — Prefer numerically stable floating-point operations - inconsistent-equality-implementation — Disallow mixing derived and written equality or hashing implementations - manual-midpoint — Prefer midpoint operations that cannot overflow intermediate arithmetic - no-approx-constant — Disallow numeric literals that approximate well-known constants - no-compare-neg-zero — Disallow comparisons with negative zero - no-float-loop-counter — Disallow float loop counters accumulated by repeated addition - no-floating-point-equality — Disallow exact equality comparisons between floating-point values - no-integer-division-in-float-context — Disallow integer division whose result immediately becomes a float - no-invalid-clamp — Disallow clamp calls with invalid constant bounds - no-negated-float-comparison — Disallow negated floating-point ordering comparisons that accept NaN - no-overflow-check-after-overflow — Disallow overflow tests that perform the overflowing operation first - no-reversed-range — Disallow constant ranges whose start exceeds their end - no-self-compare — Disallow comparisons with identical deterministic operands - use-isnan — Require NaN predicates for equality-based tests Suspicious - almost-complete-range — Disallow character ranges stopping before their conventional endpoint - almost-swapped — Disallow assignments that overwrite a value before swapping it - ambiguous-precedence — Require grouping where operator precedence is easy to misread - ineffective-break-in-switch — Disallow nonterminal switch breaks inside an enclosing loop - loop-single-iteration — Disallow loops whose control flow cannot reach another iteration - misrefactored-assign-op — Disallow compound assignments that repeat the assigned place - mixed-read-write-expression — Disallow reading and mutating the same place in one combined expression - no-array-fill-with-reference-type — Disallow Array.fill values that share mutable references - no-cond-assign — Disallow assignment in conditions - no-debugger — Disallow debugger statements - no-diverging-subexpression — Disallow diverging operations inside continuing expressions - no-drop-of-trivial-value — Disallow dropping values without destructors - no-duplicate-code — Disallow repeated nontrivial code regions - no-duplicate-else-if — Disallow else-if conditions made unreachable by earlier conditions - no-duplicate-match-arms — Disallow match arms with identical bodies - no-duplicate-test-hook — Disallow duplicate lifecycle hooks in one test suite - no-empty-module — Disallow empty undecorated module declarations - no-empty-pattern — Disallow empty destructuring patterns - no-erasing-operation — Disallow operations that erase their operand into a constant - no-focused-test — Disallow focused tests and suites - no-identity-operation — Disallow arithmetic with an operand that cannot change the result - no-mutated-range-bound — Disallow mutating range bounds during iteration over that range - no-negation-in-equality-check — Disallow negation in equality checks - no-return-assign — Disallow assignment within an explicit or implicit return value - no-self-assignment — Disallow assigning a stable place to itself - no-single-promise-race — Disallow Promise.race over one Promise - no-skipped-test — Disallow skipped tests and suites - no-template-curly-in-string — Disallow template interpolation in regular strings - no-todo — Disallow calls to the canonical todo function - no-unused-map-result — Disallow unused Array.map and Iterator.map results - no-useless-concat — Disallow concatenating adjacent string literals - no-useless-constructor — Disallow constructors that only repeat implicit construction behavior - no-useless-default-assignment — Disallow defaults that cannot be selected by the checked input type - no-useless-length-check — Disallow length checks duplicated by the guarded array operation - no-useless-promise-resolve — Disallow Promise.resolve calls that preserve the same Promise - no-useless-rename — Disallow imports, exports, and destructuring fields renamed to the same name - no-useless-return — Disallow bare returns where the function already ends - no-useless-spread — Disallow spreads that have no observable effect - no-useless-switch-case — Disallow empty switch cases adjacent to the default case - nonminimal-bool — Simplify boolean expressions with redundant or contradictory terms - nonsensical-open-options — Disallow contradictory or ineffective file open options - only-used-in-recursion — Disallow parameters used only to calculate their own recursive argument - redundant-pattern-matching — Prefer canonical result predicates over boolean pattern matches - suspicious-operand-grouping — Disallow inconsistent member pairings in comparison chains - suspicious-operator-implementation — Disallow direct operator implementations built on a different operator - temporary-assignment — Disallow assignments into discarded struct and tuple constructions - wildcard-enum-match-arm — Disallow wildcard arms when matching nominal enums Security - no-invisible-character — Disallow invisible and misleading characters in source text - no-permissive-file-permission — Disallow world-writable and decimal file permission literals - undocumented-unsafe — Require a safety rationale for every unsafe declaration and expression Performance - clone-on-copy — Disallow cloning values whose checked type is Copy - cloned-instead-of-copied — Prefer copying iterator elements whose type is Copy - drain-collect — Disallow draining a collection only to collect the same elements again - iter-cloned-collect — Prefer direct collection copying over iterator collection - iter-overeager-cloned — Delay iterator cloning until after operations that discard elements - large-variant — Disallow variants that disproportionately enlarge an inline union - manual-copy — Replace element-by-element copy loops with a bulk copy operation - manual-extend — Prefer extend over loops that insert every iterated value - manual-fill — Prefer fill over an index loop assigning one repeated value - manual-filter-map — Prefer filterMap when removing undefined values from a mapped array - manual-retain — Prefer retain over replacing an owned array with its filtered result - manual-try-fold — Prefer Iterator.tryFold over reducing a propagated Result accumulator - missing-spin-loop — Require a processor hint in atomic busy-wait loops - needless-borrow-of-copy — Prefer passing small Copy scalars by value - needless-collect — Disallow materializing an Iterator before a terminal operation - needless-pass-by-value — Disallow passing parameters by value when they are never consumed or mutated - no-accumulating-spread — Disallow repeated accumulator spreads within iterations - no-allocation-for-comparison — Disallow allocating conversions performed only to compare - no-await-in-promise-methods — Disallow awaiting elements passed to Promise concurrency methods - no-zero-iterator-drop — Disallow Iterator.drop with a constant zero count - prefer-array-search — Prefer direct Array search operations - prefer-clear — Prefer clear over discarding a complete drain - prefer-clone-from — Prefer Clone.cloneFrom when replacing a cloneable value - prefer-eager-fallback — Prefer eager fallbacks when deferred evaluation cannot avoid work - prefer-find-map — Prefer findMap over separate mapping and search operations - prefer-flat-map — Prefer flatMap over a map followed by a one-level flatten - prefer-lazy-fallback — Prefer lazy fallbacks when eager arguments perform avoidable work - prefer-length-over-count — Prefer stored array length over counting an unchanged iterator - prefer-map-entry — Prefer one map entry operation over a guarded insertion - prefer-map-has — Prefer Map.has over Map.get when only key presence is observed - prefer-map-keys-values — Prefer Map.keys or Map.values when one entry component is unused - prefer-multiplication-over-power — Prefer multiplication over squaring with exponentiation - prefer-single-call — Combine consecutive Array.push or Array.unshift calls - prefer-slice-parameter — Prefer slice parameters over borrowed arrays - prefer-with-capacity — Prefer withCapacity over immediate reservation after construction - redundant-clone — Disallow clones proven unnecessary by ownership and liveness - redundant-closure — Disallow closures that only forward their arguments to another function - redundant-iter-cloned — Disallow cloning iterator elements that are only borrowed afterward - repeated-string-growth — Disallow repeatedly rebuilding a growing string in an iteration - same-item-push — Prefer bulk initialization over repeatedly pushing one invariant value - suboptimal-float-operation — Prefer faster floating-point operations when their precision is sufficient - unnecessary-fold — Prefer a specialized iterator operation over an equivalent fold - unnecessary-sort-comparator — Disallow comparators that reproduce the natural ordering - unused-peekable — Disallow peekable iterators that are never peeked Style - adjacent-overload-signatures — Require overload signatures for one declaration to be adjacent - boolean-prefix — Require predicate prefixes for boolean values - branches-sharing-code — Extract identical branch prefixes or suffixes - comment-style — Require canonical style for comments and documentation - decimal-bitwise-operand — Disallow opaque decimal masks in bitwise operations - default-case-last — Require the default switch case last - default-param-last — Require optional and defaulted parameters after required parameters - dot-notation — Prefer dot notation for statically named member access - double-comparisons — Prefer one comparison over an equivalent pair of comparisons - excessive-nesting — Disallow control flow nested beyond four levels - filename-case — Require lowercase kebab-case source filenames - grouped-accessor-pairs — Require getter and setter pairs to be adjacent - identifier-case — Require canonical casing for declared identifiers - inconsistent-field-order — Require nominal literal fields in declaration order - manual-abs-diff — Prefer absDiff over equivalent branching subtraction - manual-ascii-check — Prefer character predicates over ASCII range checks - manual-assert — Prefer assertions over conditional panics - manual-assert-equal — Prefer equality assertions over asserting a comparison - manual-checked-division — Prefer checked division over manual zero guards - manual-clamp — Prefer clamp over nested bound comparisons - manual-div-ceil — Prefer divideCeil over an adjusted integer numerator - manual-euclidean-remainder — Prefer remainderEuclidean over its manual double-remainder form - manual-filter — Prefer Array.filter over manually collecting matching elements - manual-find — Prefer find over a loop returning the first matching element - manual-integer-log — Prefer integerLog2 over equivalent base-two integer logarithms - manual-is-finite — Prefer .isFinite() over equivalent infinity comparisons - manual-is-infinite — Prefer .isInfinite() over equivalent infinity comparisons - manual-is-multiple-of — Prefer isMultipleOf over a remainder comparison with zero - manual-is-power-of-two — Prefer isPowerOfTwo over equivalent unsigned integer tests - manual-isolate-lowest-one — Prefer isolateLowestOne over its manual wrapping bitwise form - manual-iterator-inspect — Prefer Iterator.inspect when mapping observes and returns each value - manual-let-else — Prefer let-else over an equivalent match binding - manual-map — Prefer Array.map over manually collecting transformed elements - manual-ok-err — Prefer Result projection methods over equivalent pattern matching - manual-pop-if — Prefer Array.popIf over conditionally popping the last element - manual-range-contains — Prefer range membership over equivalent bound comparisons - manual-range-pattern — Prefer range patterns over enumerating consecutive values - manual-result-tap — Prefer Result tap methods when mapping observes and returns its payload - manual-rotate — Prefer integer rotation operations over equivalent shift expressions - manual-saturating-arithmetic — Prefer saturating arithmetic over equivalent manual bounds logic - manual-signum — Prefer signum over equivalent sign branching - manual-strict-comparison — Prefer strict comparison over offsetting an operand by one - manual-strip — Prefer prefix or suffix stripping over checking and slicing - manual-struct-conversion — Prefer conversions over field-by-field reconstruction - manual-take — Prefer take over moving a value and assigning its default - manual-unwrap-or — Prefer Result fallback methods over equivalent pattern matching - manual-unwrap-or-default — Prefer unwrapOrDefault over equivalent Result pattern matching - map-identity — Disallow rebuilding an owned array through an identity map - missing-docs — Require documentation for named declarations - needless-borrow — Disallow direct borrows that are immediately dereferenced - needless-question-mark — Disallow propagation immediately wrapped in the same Result type - no-block-in-condition — Disallow block expressions in conditions and scrutinees - no-boolean-literal-compare — Disallow comparing boolean values to boolean literals - no-collapsible-if — Prefer one condition over nested if statements without alternatives - no-collapsible-match — Merge nested matches whose nested pattern fits the enclosing arm - no-empty — Disallow uncommented empty block statements - no-empty-function — Disallow empty functions - no-empty-static-block — Disallow empty static and compile-time initialization blocks - no-explicit-iterator-in-for-of — Disallow explicit iterator calls in for-of loops - no-inferrable-type-annotation — Disallow annotations identical to an inferred scalar type - no-literal-unwrap — Disallow immediately unwrapping a known successful result variant - no-lone-block — Disallow nested blocks with no scoping effect - no-lonely-if — Disallow an if statement as the only statement in an else block - no-multi-assign — Disallow chained assignment - no-needless-boolean-branch — Disallow conditionals that only produce opposite boolean literals - no-needless-continue — Disallow continue where control already proceeds to the same iteration - no-needless-match — Disallow matches that reconstruct their scrutinee unchanged - no-negated-condition — Prefer positive conditions when both branches are present - no-nested-ternary — Disallow nested ternary expressions - no-redundant-closure-call — Disallow parameterless lambdas called where they are defined - no-redundant-full-slice — Disallow indexing a slice with the complete range - no-redundant-label — Disallow labels on transfers to the target selected without a label - no-redundant-match-guard — Prefer literal patterns over equivalent equality guards - no-redundant-type-constraint — Disallow generic constraints equal to the implicit top type - no-single-binding-match — Prefer direct evaluation over a match with one irrefutable arm - no-static-only-class — Disallow classes containing only static members - no-this-alias — Disallow aliasing the receiver into a binding - no-unit-binding — Disallow binding unit values - no-unnecessary-array-flat-depth — Disallow an explicit default array flattening depth - no-unnecessary-slice-end — Disallow slice end arguments that cannot shorten the result - no-unnecessary-template-expression — Disallow template expressions without text or conversion - no-unnecessary-type-parameter — Disallow type parameters that add no relationship or precision - no-used-underscore-binding — Disallow using bindings named as unused - object-shorthand — Require object property shorthand where equivalent - operator-assignment — Require compound assignment where equivalent - prefer-array-literal — Prefer an empty array literal over the canonical Array constructor - prefer-code-point — Prefer Unicode code-point operations over UTF-16 code-unit operations - prefer-const — Require const for bindings never reassigned after initialization - prefer-else — Prefer else in compact terminal value decisions - prefer-enumerate — Prefer indexed iteration over manually counting values - prefer-equality-over-pattern — Prefer equality over matching one complete scalar constant - prefer-exclusive-range — Prefer exclusive ranges over inclusive ranges offset by one - prefer-expect-diagnostic — Prefer diagnostic expectations for local suppressions - prefer-exponentiation-operator — Prefer the exponentiation operator to a well-known power function - prefer-expression-initialization — Prefer expression initialization over staged assignments - prefer-first-last — Prefer first and last accessors over equivalent indexing - prefer-flat — Prefer Array.flat over spreading nested arrays into concat - prefer-for-of — Prefer for-of when a loop only indexes one array - prefer-for-of-over-for-each — Prefer for-of over sequential forEach callbacks - prefer-function-type — Prefer function types over single-signature structural types - prefer-implicit-return — Prefer expression bodies for lambdas that only return one value - prefer-is-empty — Prefer isEmpty over comparisons with zero length - prefer-loop-condition — Prefer loop conditions over leading conditional breaks - prefer-map-over-and-then — Prefer Result map methods when chaining only rewraps one variant - prefer-match — Prefer match over switch statements and repeated equality chains - prefer-maybe — Prefer the maybe operator over manual propagation - prefer-method — Prefer methods when the first parameter establishes a receiver - prefer-negative-index — Prefer negative indices in equivalent at calls - prefer-nested-or-pattern — Prefer nesting or-patterns inside their shared nominal pattern - prefer-nth — Prefer nth over drop followed by first - prefer-nullish-coalescing — Prefer nullish coalescing when a nullish value selects a fallback - prefer-optional-chain — Prefer optional chaining to equivalent nullish conditionals - prefer-readonly — Require readonly for private fields never mutated after initialization - prefer-regex-literals — Prefer regex literals for constant patterns and flags - prefer-regexp-exec — Prefer RegExp.exec when regular-expression match details are consumed - prefer-return-this-type — Prefer this as the return type when a method only returns its receiver - prefer-self-closing-tree — Prefer self-closing tree elements without children - prefer-set-over-unit-map — Prefer sets over maps whose values are unit - prefer-slice-pattern — Prefer slice patterns over indexing after a length guard - prefer-string-raw — Prefer String.raw when backslashes are escaped only to preserve themselves - prefer-string-replace-all — Prefer String.replaceAll when every occurrence is replaced - prefer-string-slice — Prefer String.slice over the legacy String.substring operation - prefer-string-starts-ends-with — Prefer startsWith and endsWith for string boundary tests - prefer-template — Prefer template literals for string concatenation - prefer-tuple-swap — Prefer tuple assignment for swaps - prefer-unary-negation — Prefer unary negation over multiplying or dividing by -1 - prefer-weakest-access — Prefer the weakest access form required by a value's uses - redundant-forwarding-function — Discourage functions that only forward their parameters unchanged - require-accessor-pair — Disallow setters without a matching getter - require-array-join-separator — Require an explicit array join separator - require-diagnostic-reason — Require reasons for diagnostic suppressions - require-is-empty-with-length — Require isEmpty alongside a length accessor - unnecessary-fallible-conversion — Simplify fallible integer conversions that cannot fail - unnecessary-filter-map — Disallow filterMap callbacks with a definitely defined result - unnecessary-unwrap — Disallow unwrap after checked control flow proves the Result variant - unused-enumerate-index — Disallow indexed iteration when its index is unused - while-let-loop — Prefer while-let over an unconditional pattern loop - wrong-receiver-convention — Require receiver forms matching the method's name convention - yoda — Disallow literal-first comparisons