eslint-rule-forge 0.1.0 → 0.2.0

package/README.md

@@ -87,6 +87,27 @@ assertion (`x as string | null`) then makes the rule more cautious, and a
 narrowing one (`x!`, `v as string` on an `unknown`), which the checker cannot
 verify, changes nothing.
 
+## Negation
+
+Writing the negation of a condition the short way, as a fix that removes a
+ternary or turns a filter into a loop has to.
+
+| Helper                        | What it gives                                                                                                             |
+| :---------------------------- | :------------------------------------------------------------------------------------------------------------------------ |
+| `negationOf`                  | `a !== b` for `a === b`, `!a && !b` for `a \|\| b`, `a` for `!a` (when a boolean), else `!a`; parenthesized as an operand |
+| `prefixedNegationOf`          | `!a`, `!f(x)`, `!(a === b)`: a `!` in front, with parentheses only when it needs them                                     |
+| `isComparison`                | whether a node is an equality or a relational comparison                                                                  |
+| `isExactlyInvertible`         | whether inverting a comparison's operator is its exact negation: always for an equality, for `<` only without `NaN`       |
+| `invertedComparisonText`      | the comparison's source with its operator inverted                                                                        |
+| `needsParenthesesAsOperandOf` | whether a node needs parentheses as an operand of `&&` or `\|\|`                                                          |
+| `createGetLayerTypes`         | a function giving a node's type at every type-wrapper layer, which the checks above ask                                   |
+
+`negationOf` gives `undefined` when the only exact negation is `!!a` (for an
+`a` that may not be a boolean) or `!(a < b)` (for operands that may be `NaN`),
+so that a rule can choose between `prefixedNegationOf` and giving up. Where
+only the truthiness of the negation is read, such as the test of an `if`, its
+context may call every node a boolean.
+
 ## Parentheses
 
 The range and the text of a node leave out the parentheses written around it.

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 export * from './bindings.mjs';
 export * from './imports.mjs';
+export * from './negation.mjs';
 export * from './parentheses.mjs';
 export * from './type-wrappers.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}

package/dist/index.mjs

@@ -1,5 +1,6 @@
 export * from './bindings.mjs';
 export * from './imports.mjs';
+export * from './negation.mjs';
 export * from './parentheses.mjs';
 export * from './type-wrappers.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}

package/dist/negation.d.mts

@@ -0,0 +1,102 @@
+import { type ParserServicesWithTypeInformation, type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import type { DeepReadonly, StrictPick } from 'ts-type-forge';
+import * as ts from 'typescript';
+/** Each comparison operator, and the one that is true exactly when it is not. */
+export declare const INVERTED_COMPARISON_OPERATOR: {
+    readonly '===': '!==';
+    readonly '!==': '===';
+    readonly '==': '!=';
+    readonly '!=': '==';
+    readonly '<': '>=';
+    readonly '>=': '<';
+    readonly '>': '<=';
+    readonly '<=': '>';
+};
+export type ComparisonOperator = keyof typeof INVERTED_COMPARISON_OPERATOR;
+export type ComparisonExpression = DeepReadonly<TSESTree.BinaryExpression> & Readonly<{
+    operator: ComparisonOperator;
+}>;
+/**
+ * The type of a node at each of its type-wrapper layers, outermost first (see
+ * {@link typeWrapperLayers}).
+ */
+export type GetLayerTypes = (node: DeepReadonly<TSESTree.Node>) => readonly ts.Type[];
+/**
+ * Builds a {@link GetLayerTypes}: `x as A` gives the types of `x as A` and of
+ * `x`.
+ *
+ * A conclusion a rule draws from a type is drawn only when it holds for every
+ * one of them. A widening `as` (`b as boolean | number`) is then the author
+ * saying the value may be something else, and is respected, while a narrowing
+ * one (`n as unknown as boolean`) leaves the value's own type to decide.
+ */
+export declare const createGetLayerTypes: (services: StrictPick<ParserServicesWithTypeInformation, 'esTreeNodeToTSNodeMap' | 'program'>) => GetLayerTypes;
+export declare const isComparison: (node: DeepReadonly<TSESTree.Node>) => node is ComparisonExpression;
+/**
+ * Whether inverting the operator gives exactly the negation.
+ *
+ * An equality always does. A relational comparison does unless an operand
+ * converts to `NaN`: every relational comparison with `NaN` is `false`, so
+ * `!(a < b)` is `true` there while `a >= b` is `false`. It cannot when both
+ * sides are strings (compared as strings), or both are numeric values that are
+ * never `NaN` — number literals, `bigint`, booleans, and number brands that
+ * declare `NaNValue: false` (`ValidNumber`, `Int`, `FiniteNumber`, …).
+ *
+ * `getLayerTypes` gives an operand's type at each of its type-wrapper layers,
+ * and every one of them has to say so: `(v as number) < 1` may be `NaN` even
+ * when `v` is a `ValidNumber`, and `(n as ValidNumber) < 1` still may when `n`
+ * is a `number`.
+ */
+export declare const isExactlyInvertible: (node: ComparisonExpression, getLayerTypes: GetLayerTypes, checker: ts.TypeChecker) => boolean;
+/**
+ * The source of `node` with its operator inverted, and everything else —
+ * operands, comments, line breaks — as written.
+ */
+export declare const invertedComparisonText: (node: ComparisonExpression, sourceCode: DeepReadonly<TSESLint.SourceCode>) => string;
+/** What {@link negationOf} needs to know about the code it negates. */
+export type NegationContext = Readonly<{
+    sourceCode: DeepReadonly<TSESLint.SourceCode>;
+    checker: ts.TypeChecker;
+    getLayerTypes: GetLayerTypes;
+    /**
+     * Whether `node`'s value is a boolean, so that the negation of `!node` may
+     * be `node` itself. Where only the truthiness of the negation is read — the
+     * test of an `if` — any value will do, and this may answer `true` for every
+     * node.
+     */
+    isBoolean: (node: DeepReadonly<TSESTree.Expression>) => boolean;
+}>;
+/**
+ * The negation of `node`, written the short way, as the source text of an
+ * operand of `operandOf` (parenthesized if need be), or of a whole expression
+ * when `operandOf` is `undefined`:
+ *
+ * | `node`             | negation          | when                                  |
+ * | :----------------- | :---------------- | :------------------------------------ |
+ * | `!a`               | `a`               | `a` is a boolean (`context.isBoolean`) |
+ * | `a === b`          | `a !== b`         | always                                |
+ * | `a < b`            | `a >= b`          | no operand can be `NaN`               |
+ * | `a && b`, `a \|\| b` | `!a \|\| !b`, `!a && !b` | always, each side negated the same way |
+ * | anything else      | `!a`, `!(a)`      | always                                |
+ *
+ * `undefined` when the first two rows' condition does not hold: then the only
+ * exact negation is `!!a` or `!(a < b)`, and a caller decides whether to
+ * write it (with {@link prefixedNegationOf}) or to give up. Inside `&&` and
+ * `||`, a side with no short negation is written with `!`.
+ *
+ * The node is taken as written: a comparison under a type wrapper is not
+ * looked into, since inverting it would drop the wrapper.
+ */
+export declare const negationOf: (node: DeepReadonly<TSESTree.Expression>, context: NegationContext, operandOf: '&&' | '||' | undefined) => string | undefined;
+/**
+ * `!node`, with `node` parenthesized unless `!` already binds to all of it:
+ * `!a`, `!f(x)`, `!(a === b)`.
+ */
+export declare const prefixedNegationOf: (node: DeepReadonly<TSESTree.Expression>, sourceCode: DeepReadonly<TSESLint.SourceCode>) => string;
+/**
+ * Whether `node`, written as an operand of `operator`, needs parentheses to
+ * stay one operand: `a || b` under `&&`, `a ?? b` under either, and anything
+ * binding looser than both (`a ? b : c`, `a = b`, …).
+ */
+export declare const needsParenthesesAsOperandOf: (node: DeepReadonly<TSESTree.Node>, operator: '&&' | '||') => boolean;
+//# sourceMappingURL=negation.d.mts.map

package/dist/negation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negation.d.mts","sourceRoot":"","sources":["../src/negation.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iCAAiC,EACtC,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAKjC,iFAAiF;AACjF,eAAO,MAAM,4BAA4B;aACvC,KAAK,EAAE,KAAK;aACZ,KAAK,EAAE,KAAK;aACZ,IAAI,EAAE,IAAI;aACV,IAAI,EAAE,IAAI;aACV,GAAG,EAAE,IAAI;aACT,IAAI,EAAE,GAAG;aACT,GAAG,EAAE,IAAI;aACT,IAAI,EAAE,GAAG;CACD,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,4BAA4B,CAAC;AAE3E,MAAM,MAAM,oBAAoB,GAAG,YAAY,CAAC,QAAQ,CAAC,gBAAgB,CAAC,GACxE,QAAQ,CAAC;IAAE,QAAQ,EAAE,kBAAkB,CAAA;CAAE,CAAC,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,CAC1B,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAC9B,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC;AAExB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,aAElB,UAAU,CAClB,iCAAiC,EACjC,uBAAuB,GAAG,SAAS,CACpC,KACA,aASF,CAAC;AAEJ,eAAO,MAAM,YAAY,SACjB,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAChC,IAAI,IAAI,oBAEiD,CAAC;AAE7D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,SACxB,oBAAoB,iBACX,aAAa,WACnB,EAAE,CAAC,WAAW,KACtB,OAcF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,SAC3B,oBAAoB,cACd,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,KAC5C,MAoBF,CAAC;AAEF,uEAAuE;AACvE,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,UAAU,EAAE,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC9C,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC;IACxB,aAAa,EAAE,aAAa,CAAC;IAC7B;;;;;OAKG;IACH,SAAS,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC;CACjE,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,UAAU,SACf,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,WAC9B,eAAe,aACb,IAAI,GAAG,IAAI,GAAG,SAAS,KACjC,MAAM,GAAG,SAIX,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,SACvB,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,cAC3B,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,KAC5C,MAIF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,SAChC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,YACvB,IAAI,GAAG,IAAI,KACpB,OAAqD,CAAC"}

package/dist/negation.mjs

@@ -0,0 +1,215 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import { typeWrapperLayers } from './type-wrappers.mjs';
+
+
+export const INVERTED_COMPARISON_OPERATOR = {
+    '===': '!==',
+    '!==': '===',
+    '==': '!=',
+    '!=': '==',
+    '<': '>=',
+    '>=': '<',
+    '>': '<=',
+    '<=': '>',
+};
+
+
+
+
+
+
+
+
+
+export const createGetLayerTypes = (services) => (node) => {
+    const checker = services.program.getTypeChecker();
+    return typeWrapperLayers(node).map((layer) => checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(asNode(layer))));
+};
+export const isComparison = (node) => node.type === AST_NODE_TYPES.BinaryExpression &&
+    Object.hasOwn(INVERTED_COMPARISON_OPERATOR, node.operator);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const isExactlyInvertible = (node, getLayerTypes, checker) => {
+    if (!RELATIONAL_OPERATORS.has(node.operator)) {
+        return true;
+    }
+    const sides = [
+        ...getLayerTypes(node.left),
+        ...getLayerTypes(node.right),
+    ].flatMap(constituentsOf);
+    return (sides.every((type) => (type.flags & ts.TypeFlags.StringLike) !== 0) ||
+        sides.every((type) => isNeverNaN(type, checker)));
+};
+
+
+
+
+export const invertedComparisonText = (node, sourceCode) => {
+    const text = sourceCode.getText(asNode(node));
+    const operator = sourceCode.getFirstTokenBetween(asNode(node.left), asNode(node.right), (token) => token.value === node.operator);
+    if (operator === null) {
+        return `${sourceCode.getText(asNode(node.left))} ${INVERTED_COMPARISON_OPERATOR[node.operator]} ${sourceCode.getText(asNode(node.right))}`;
+    }
+    const [start] = node.range;
+    return [
+        text.slice(0, operator.range[0] - start),
+        INVERTED_COMPARISON_OPERATOR[node.operator],
+        text.slice(operator.range[1] - start),
+    ].join('');
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const negationOf = (node, context, operandOf) => {
+    const negation = shortNegationOf(node, context);
+    return negation === undefined ? undefined : asOperand(negation, operandOf);
+};
+
+
+
+
+export const prefixedNegationOf = (node, sourceCode) => {
+    const text = sourceCode.getText(asNode(node));
+    return BINDS_AS_TIGHT_AS_UNARY.has(node.type) ? `!${text}` : `!(${text})`;
+};
+
+
+
+
+
+export const needsParenthesesAsOperandOf = (node, operator) => isLooserThan(precedenceOf(node), operator);
+const shortNegationOf = (node, context) => {
+    if (node.type === AST_NODE_TYPES.UnaryExpression && node.operator === '!') {
+        return context.isBoolean(node.argument)
+            ? {
+                text: context.sourceCode.getText(asNode(node.argument)),
+                precedence: precedenceOf(node.argument),
+            }
+            : undefined;
+    }
+    if (isComparison(node)) {
+        return isExactlyInvertible(node, context.getLayerTypes, context.checker)
+            ? {
+                text: invertedComparisonText(node, context.sourceCode),
+                precedence: 'tighter',
+            }
+            : undefined;
+    }
+    if (node.type === AST_NODE_TYPES.LogicalExpression &&
+        node.operator !== '??') {
+        const operator = node.operator === '&&' ? '||' : '&&';
+        const side = (operand) => asOperand(shortNegationOf(operand, context) ?? {
+            text: prefixedNegationOf(operand, context.sourceCode),
+            precedence: 'tighter',
+        }, operator);
+        return {
+            text: `${side(node.left)} ${operator} ${side(node.right)}`,
+            precedence: operator,
+        };
+    }
+    return {
+        text: prefixedNegationOf(node, context.sourceCode),
+        precedence: 'tighter',
+    };
+};
+const asOperand = (negation, operator) => operator !== undefined && isLooserThan(negation.precedence, operator)
+    ? `(${negation.text})`
+    : negation.text;
+const isLooserThan = (precedence, operator) => precedence === 'looser' || (operator === '&&' && precedence === '||');
+const precedenceOf = (node) => {
+    if (node.type === AST_NODE_TYPES.LogicalExpression) {
+
+        return node.operator === '??' ? 'looser' : node.operator;
+    }
+    return LOOSER_THAN_LOGICAL.has(node.type) ? 'looser' : 'tighter';
+};
+const LOOSER_THAN_LOGICAL = new Set([
+    AST_NODE_TYPES.ArrowFunctionExpression,
+    AST_NODE_TYPES.AssignmentExpression,
+    AST_NODE_TYPES.ConditionalExpression,
+    AST_NODE_TYPES.SequenceExpression,
+    AST_NODE_TYPES.YieldExpression,
+]);
+
+const BINDS_AS_TIGHT_AS_UNARY = new Set([
+    AST_NODE_TYPES.ArrayExpression,
+    AST_NODE_TYPES.AwaitExpression,
+    AST_NODE_TYPES.CallExpression,
+    AST_NODE_TYPES.ChainExpression,
+    AST_NODE_TYPES.Identifier,
+    AST_NODE_TYPES.Literal,
+    AST_NODE_TYPES.MemberExpression,
+    AST_NODE_TYPES.MetaProperty,
+    AST_NODE_TYPES.NewExpression,
+    AST_NODE_TYPES.ObjectExpression,
+    AST_NODE_TYPES.TaggedTemplateExpression,
+    AST_NODE_TYPES.TemplateLiteral,
+    AST_NODE_TYPES.ThisExpression,
+    AST_NODE_TYPES.TSNonNullExpression,
+    AST_NODE_TYPES.UnaryExpression,
+]);
+const RELATIONAL_OPERATORS = new Set(['<', '<=', '>', '>=']);
+const constituentsOf = (type) => type.isUnion() ? type.types : [type];
+const isNeverNaN = (type, checker) => {
+
+
+
+    const neverNaNFlags = ts.TypeFlags.NumberLiteral |
+        ts.TypeFlags.BigIntLike |
+        ts.TypeFlags.BooleanLike |
+        ts.TypeFlags.Null;
+    if ((type.flags & neverNaNFlags) !== 0) {
+        return true;
+    }
+    if (!type.isIntersection()) {
+        return false;
+    }
+    const brand = checker.getPropertyOfType(type, 'NaNValue');
+    if (brand === undefined) {
+        return false;
+    }
+    const brandType = checker.getTypeOfSymbol(brand);
+    return (type.types.some((member) => (member.flags & ts.TypeFlags.NumberLike) !== 0) &&
+        (brandType.flags & ts.TypeFlags.BooleanLiteral) !== 0 &&
+        checker.typeToString(brandType) === 'false');
+};
+
+
+
+
+const asNode = (node) => 
+
+node;
+//# sourceMappingURL=negation.mjs.map

package/dist/negation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"negation.mjs","sourceRoot":"","sources":["../src/negation.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,GAIf,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,uEAAuE;AAEvE,iFAAiF;AACjF,MAAM,CAAC,MAAM,4BAA4B,GAAG;IAC1C,KAAK,EAAE,KAAK;IACZ,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,GAAG;IACT,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,GAAG;CACD,CAAC;AAeX;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAC9B,CACE,QAGC,EACc,EAAE,CACnB,CAAC,IAAI,EAAE,EAAE;IACP,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;IAElD,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3C,OAAO,CAAC,iBAAiB,CACvB,QAAQ,CAAC,qBAAqB,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAClD,CACF,CAAC;AACJ,CAAC,CAAC;AAEJ,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,IAAiC,EACH,EAAE,CAChC,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,gBAAgB;IAC7C,MAAM,CAAC,MAAM,CAAC,4BAA4B,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;AAE7D;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,IAA0B,EAC1B,aAA4B,EAC5B,OAAuB,EACd,EAAE;IACX,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,KAAK,GAAG;QACZ,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;QAC3B,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC;KAC7B,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IAE1B,OAAO,CACL,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACnE,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CACjD,CAAC;AACJ,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,IAA0B,EAC1B,UAA6C,EACrC,EAAE;IACV,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAE9C,MAAM,QAAQ,GAAG,UAAU,CAAC,oBAAoB,CAC9C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EACjB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAClB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,QAAQ,CACzC,CAAC;IAEF,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtB,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,4BAA4B,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;IAC7I,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;IAE3B,OAAO;QACL,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACxC,4BAA4B,CAAC,IAAI,CAAC,QAAQ,CAAC;QAC3C,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;KACtC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACb,CAAC,CAAC;AAgBF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,IAAuC,EACvC,OAAwB,EACxB,SAAkC,EACd,EAAE;IACtB,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAEhD,OAAO,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AAC7E,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,IAAuC,EACvC,UAA6C,EACrC,EAAE;IACV,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAE9C,OAAO,uBAAuB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC;AAC5E,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACzC,IAAiC,EACjC,QAAqB,EACZ,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;AAazD,MAAM,eAAe,GAAG,CACtB,IAAuC,EACvC,OAAwB,EACF,EAAE;IACxB,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,eAAe,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;QAC1E,OAAO,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC;YACrC,CAAC,CAAC;gBACE,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACvD,UAAU,EAAE,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC;aACxC;YACH,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;IAED,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;QACvB,OAAO,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,OAAO,CAAC;YACtE,CAAC,CAAC;gBACE,IAAI,EAAE,sBAAsB,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC;gBACtD,UAAU,EAAE,SAAS;aACtB;YACH,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;IAED,IACE,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,iBAAiB;QAC9C,IAAI,CAAC,QAAQ,KAAK,IAAI,EACtB,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;QAEtD,MAAM,IAAI,GAAG,CAAC,OAA0C,EAAU,EAAE,CAClE,SAAS,CACP,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI;YACnC,IAAI,EAAE,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC;YACrD,UAAU,EAAE,SAAS;SACtB,EACD,QAAQ,CACT,CAAC;QAEJ,OAAO;YACL,IAAI,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;YAC1D,UAAU,EAAE,QAAQ;SACrB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,kBAAkB,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC;QAClD,UAAU,EAAE,SAAS;KACtB,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,SAAS,GAAG,CAChB,QAAkB,EAClB,QAAiC,EACzB,EAAE,CACV,QAAQ,KAAK,SAAS,IAAI,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;IACnE,CAAC,CAAE,IAAI,QAAQ,CAAC,IAAI,GAAa;IACjC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;AAEpB,MAAM,YAAY,GAAG,CAAC,UAAsB,EAAE,QAAqB,EAAW,EAAE,CAC9E,UAAU,KAAK,QAAQ,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,UAAU,KAAK,IAAI,CAAC,CAAC;AAExE,MAAM,YAAY,GAAG,CAAC,IAAiC,EAAc,EAAE;IACrE,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,iBAAiB,EAAE,CAAC;QACnD,8DAA8D;QAC9D,OAAO,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;IAC3D,CAAC;IAED,OAAO,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAgC,IAAI,GAAG,CAAC;IAC/D,cAAc,CAAC,uBAAuB;IACtC,cAAc,CAAC,oBAAoB;IACnC,cAAc,CAAC,qBAAqB;IACpC,cAAc,CAAC,kBAAkB;IACjC,cAAc,CAAC,eAAe;CAC/B,CAAC,CAAC;AAEH,kEAAkE;AAClE,MAAM,uBAAuB,GAAgC,IAAI,GAAG,CAAC;IACnE,cAAc,CAAC,eAAe;IAC9B,cAAc,CAAC,eAAe;IAC9B,cAAc,CAAC,cAAc;IAC7B,cAAc,CAAC,eAAe;IAC9B,cAAc,CAAC,UAAU;IACzB,cAAc,CAAC,OAAO;IACtB,cAAc,CAAC,gBAAgB;IAC/B,cAAc,CAAC,YAAY;IAC3B,cAAc,CAAC,aAAa;IAC5B,cAAc,CAAC,gBAAgB;IAC/B,cAAc,CAAC,wBAAwB;IACvC,cAAc,CAAC,eAAe;IAC9B,cAAc,CAAC,cAAc;IAC7B,cAAc,CAAC,mBAAmB;IAClC,cAAc,CAAC,eAAe;CAC/B,CAAC,CAAC;AAEH,MAAM,oBAAoB,GACxB,IAAI,GAAG,CAAqB,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;AAEtD,MAAM,cAAc,GAAG,CAAC,IAAa,EAAsB,EAAE,CAC3D,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,IAAI,CAAW,CAAC;AAElD,MAAM,UAAU,GAAG,CAAC,IAAa,EAAE,OAAuB,EAAW,EAAE;IACrE,wEAAwE;IACxE,0EAA0E;IAC1E,sEAAsE;IACtE,MAAM,aAAa,GACjB,EAAE,CAAC,SAAS,CAAC,aAAa;QAC1B,EAAE,CAAC,SAAS,CAAC,UAAU;QACvB,EAAE,CAAC,SAAS,CAAC,WAAW;QACxB,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC;IAEpB,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACvC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAE1D,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAEjD,OAAO,CACL,IAAI,CAAC,KAAK,CAAC,IAAI,CACb,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAC3D;QACD,CAAC,SAAS,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,cAAc,CAAC,KAAK,CAAC;QACrD,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,OAAO,CAC5C,CAAC;AACJ,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,GAAG,CAA0B,IAAqB,EAAK,EAAE;AACnE,oEAAoE;AACpE,IAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-rule-forge",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "description": "Helpers for writing typescript-eslint rules that see through type wrappers and parentheses, and resolve what a file imports.",
   "keywords": [
@@ -41,13 +41,13 @@
     "@typescript-eslint/rule-tester": "8.71.1",
     "dedent": "1.7.2",
     "eslint": "10.12.0",
-    "eslint-config-typed": "5.17.4",
-    "eslint-plugin-ts-fortress": "1.3.3",
-    "eslint-plugin-ts-type-forge": "0.8.8",
+    "eslint-config-typed": "5.19.0",
+    "eslint-plugin-ts-fortress": "1.3.4",
+    "eslint-plugin-ts-type-forge": "0.8.9",
     "prettier": "3.9.9",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
-    "ts-data-forge": "14.7.1",
+    "ts-data-forge": "14.8.0",
     "ts-repo-utils": "10.7.1"
   },
   "peerDependencies": {
@@ -65,15 +65,15 @@
   "scripts": {
     "build": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/build.mts",
     "check:ext": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-ext.mts",
-    "check:lint": "oxlint . && eslint .",
-    "check:test": "pnpm run z:vitest run",
-    "check:test:cov": "pnpm run z:vitest run --coverage",
-    "check:types": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
+    "check:lint": "node ../../tools/scripts/cmd/assert-deps-built.mts && oxlint . && eslint .",
+    "check:test": "node ../../tools/scripts/cmd/assert-deps-built.mts && pnpm run z:vitest run",
+    "check:test:cov": "node ../../tools/scripts/cmd/assert-deps-built.mts && pnpm run z:vitest run --coverage",
+    "check:types": "node ../../tools/scripts/cmd/assert-deps-built.mts && node ../../node_modules/typescript-native/bin/tsc --noEmit",
     "doc": "pnpm run gen:readme",
     "fix:fmt": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-uncommitted.mts --cwd .",
     "fix:fmt:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-diff-from.mts origin/main --cwd .",
     "fix:fmt:full": "pnpm run z:prettier .",
-    "fix:lint": "oxlint . --fix && eslint . --fix",
+    "fix:lint": "node ../../tools/scripts/cmd/assert-deps-built.mts && oxlint . --fix && eslint . --fix",
     "fmt": "pnpm run fix:fmt",
     "gen": "run-s gen:index gen:readme",
     "gen:index": "run-s gen:index:src fix:fmt",

package/src/index.mts

@@ -1,4 +1,5 @@
 export * from './bindings.mjs';
 export * from './imports.mjs';
+export * from './negation.mjs';
 export * from './parentheses.mjs';
 export * from './type-wrappers.mjs';

package/src/negation.mts

@@ -0,0 +1,356 @@
+import {
+  AST_NODE_TYPES,
+  type ParserServicesWithTypeInformation,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import type { DeepReadonly, StrictPick } from 'ts-type-forge';
+import * as ts from 'typescript';
+import { typeWrapperLayers } from './type-wrappers.mjs';
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+/** Each comparison operator, and the one that is true exactly when it is not. */
+export const INVERTED_COMPARISON_OPERATOR = {
+  '===': '!==',
+  '!==': '===',
+  '==': '!=',
+  '!=': '==',
+  '<': '>=',
+  '>=': '<',
+  '>': '<=',
+  '<=': '>',
+} as const;
+
+export type ComparisonOperator = keyof typeof INVERTED_COMPARISON_OPERATOR;
+
+export type ComparisonExpression = DeepReadonly<TSESTree.BinaryExpression> &
+  Readonly<{ operator: ComparisonOperator }>;
+
+/**
+ * The type of a node at each of its type-wrapper layers, outermost first (see
+ * {@link typeWrapperLayers}).
+ */
+export type GetLayerTypes = (
+  node: DeepReadonly<TSESTree.Node>,
+) => readonly ts.Type[];
+
+/**
+ * Builds a {@link GetLayerTypes}: `x as A` gives the types of `x as A` and of
+ * `x`.
+ *
+ * A conclusion a rule draws from a type is drawn only when it holds for every
+ * one of them. A widening `as` (`b as boolean | number`) is then the author
+ * saying the value may be something else, and is respected, while a narrowing
+ * one (`n as unknown as boolean`) leaves the value's own type to decide.
+ */
+export const createGetLayerTypes =
+  (
+    services: StrictPick<
+      ParserServicesWithTypeInformation,
+      'esTreeNodeToTSNodeMap' | 'program'
+    >,
+  ): GetLayerTypes =>
+  (node) => {
+    const checker = services.program.getTypeChecker();
+
+    return typeWrapperLayers(node).map((layer) =>
+      checker.getTypeAtLocation(
+        services.esTreeNodeToTSNodeMap.get(asNode(layer)),
+      ),
+    );
+  };
+
+export const isComparison = (
+  node: DeepReadonly<TSESTree.Node>,
+): node is ComparisonExpression =>
+  node.type === AST_NODE_TYPES.BinaryExpression &&
+  Object.hasOwn(INVERTED_COMPARISON_OPERATOR, node.operator);
+
+/**
+ * Whether inverting the operator gives exactly the negation.
+ *
+ * An equality always does. A relational comparison does unless an operand
+ * converts to `NaN`: every relational comparison with `NaN` is `false`, so
+ * `!(a < b)` is `true` there while `a >= b` is `false`. It cannot when both
+ * sides are strings (compared as strings), or both are numeric values that are
+ * never `NaN` — number literals, `bigint`, booleans, and number brands that
+ * declare `NaNValue: false` (`ValidNumber`, `Int`, `FiniteNumber`, …).
+ *
+ * `getLayerTypes` gives an operand's type at each of its type-wrapper layers,
+ * and every one of them has to say so: `(v as number) < 1` may be `NaN` even
+ * when `v` is a `ValidNumber`, and `(n as ValidNumber) < 1` still may when `n`
+ * is a `number`.
+ */
+export const isExactlyInvertible = (
+  node: ComparisonExpression,
+  getLayerTypes: GetLayerTypes,
+  checker: ts.TypeChecker,
+): boolean => {
+  if (!RELATIONAL_OPERATORS.has(node.operator)) {
+    return true;
+  }
+
+  const sides = [
+    ...getLayerTypes(node.left),
+    ...getLayerTypes(node.right),
+  ].flatMap(constituentsOf);
+
+  return (
+    sides.every((type) => (type.flags & ts.TypeFlags.StringLike) !== 0) ||
+    sides.every((type) => isNeverNaN(type, checker))
+  );
+};
+
+/**
+ * The source of `node` with its operator inverted, and everything else —
+ * operands, comments, line breaks — as written.
+ */
+export const invertedComparisonText = (
+  node: ComparisonExpression,
+  sourceCode: DeepReadonly<TSESLint.SourceCode>,
+): string => {
+  const text = sourceCode.getText(asNode(node));
+
+  const operator = sourceCode.getFirstTokenBetween(
+    asNode(node.left),
+    asNode(node.right),
+    (token) => token.value === node.operator,
+  );
+
+  if (operator === null) {
+    return `${sourceCode.getText(asNode(node.left))} ${INVERTED_COMPARISON_OPERATOR[node.operator]} ${sourceCode.getText(asNode(node.right))}`;
+  }
+
+  const [start] = node.range;
+
+  return [
+    text.slice(0, operator.range[0] - start),
+    INVERTED_COMPARISON_OPERATOR[node.operator],
+    text.slice(operator.range[1] - start),
+  ].join('');
+};
+
+/** What {@link negationOf} needs to know about the code it negates. */
+export type NegationContext = Readonly<{
+  sourceCode: DeepReadonly<TSESLint.SourceCode>;
+  checker: ts.TypeChecker;
+  getLayerTypes: GetLayerTypes;
+  /**
+   * Whether `node`'s value is a boolean, so that the negation of `!node` may
+   * be `node` itself. Where only the truthiness of the negation is read — the
+   * test of an `if` — any value will do, and this may answer `true` for every
+   * node.
+   */
+  isBoolean: (node: DeepReadonly<TSESTree.Expression>) => boolean;
+}>;
+
+/**
+ * The negation of `node`, written the short way, as the source text of an
+ * operand of `operandOf` (parenthesized if need be), or of a whole expression
+ * when `operandOf` is `undefined`:
+ *
+ * | `node`             | negation          | when                                  |
+ * | :----------------- | :---------------- | :------------------------------------ |
+ * | `!a`               | `a`               | `a` is a boolean (`context.isBoolean`) |
+ * | `a === b`          | `a !== b`         | always                                |
+ * | `a < b`            | `a >= b`          | no operand can be `NaN`               |
+ * | `a && b`, `a \|\| b` | `!a \|\| !b`, `!a && !b` | always, each side negated the same way |
+ * | anything else      | `!a`, `!(a)`      | always                                |
+ *
+ * `undefined` when the first two rows' condition does not hold: then the only
+ * exact negation is `!!a` or `!(a < b)`, and a caller decides whether to
+ * write it (with {@link prefixedNegationOf}) or to give up. Inside `&&` and
+ * `||`, a side with no short negation is written with `!`.
+ *
+ * The node is taken as written: a comparison under a type wrapper is not
+ * looked into, since inverting it would drop the wrapper.
+ */
+export const negationOf = (
+  node: DeepReadonly<TSESTree.Expression>,
+  context: NegationContext,
+  operandOf: '&&' | '||' | undefined,
+): string | undefined => {
+  const negation = shortNegationOf(node, context);
+
+  return negation === undefined ? undefined : asOperand(negation, operandOf);
+};
+
+/**
+ * `!node`, with `node` parenthesized unless `!` already binds to all of it:
+ * `!a`, `!f(x)`, `!(a === b)`.
+ */
+export const prefixedNegationOf = (
+  node: DeepReadonly<TSESTree.Expression>,
+  sourceCode: DeepReadonly<TSESLint.SourceCode>,
+): string => {
+  const text = sourceCode.getText(asNode(node));
+
+  return BINDS_AS_TIGHT_AS_UNARY.has(node.type) ? `!${text}` : `!(${text})`;
+};
+
+/**
+ * Whether `node`, written as an operand of `operator`, needs parentheses to
+ * stay one operand: `a || b` under `&&`, `a ?? b` under either, and anything
+ * binding looser than both (`a ? b : c`, `a = b`, …).
+ */
+export const needsParenthesesAsOperandOf = (
+  node: DeepReadonly<TSESTree.Node>,
+  operator: '&&' | '||',
+): boolean => isLooserThan(precedenceOf(node), operator);
+
+/**
+ * How tightly an expression binds, as far as putting it under `&&` or `||` is
+ * concerned.
+ */
+type Precedence = '&&' | '||' | 'looser' | 'tighter';
+
+type Negation = Readonly<{
+  text: string;
+  precedence: Precedence;
+}>;
+
+const shortNegationOf = (
+  node: DeepReadonly<TSESTree.Expression>,
+  context: NegationContext,
+): Negation | undefined => {
+  if (node.type === AST_NODE_TYPES.UnaryExpression && node.operator === '!') {
+    return context.isBoolean(node.argument)
+      ? {
+          text: context.sourceCode.getText(asNode(node.argument)),
+          precedence: precedenceOf(node.argument),
+        }
+      : undefined;
+  }
+
+  if (isComparison(node)) {
+    return isExactlyInvertible(node, context.getLayerTypes, context.checker)
+      ? {
+          text: invertedComparisonText(node, context.sourceCode),
+          precedence: 'tighter',
+        }
+      : undefined;
+  }
+
+  if (
+    node.type === AST_NODE_TYPES.LogicalExpression &&
+    node.operator !== '??'
+  ) {
+    const operator = node.operator === '&&' ? '||' : '&&';
+
+    const side = (operand: DeepReadonly<TSESTree.Expression>): string =>
+      asOperand(
+        shortNegationOf(operand, context) ?? {
+          text: prefixedNegationOf(operand, context.sourceCode),
+          precedence: 'tighter',
+        },
+        operator,
+      );
+
+    return {
+      text: `${side(node.left)} ${operator} ${side(node.right)}`,
+      precedence: operator,
+    };
+  }
+
+  return {
+    text: prefixedNegationOf(node, context.sourceCode),
+    precedence: 'tighter',
+  };
+};
+
+const asOperand = (
+  negation: Negation,
+  operator: '&&' | '||' | undefined,
+): string =>
+  operator !== undefined && isLooserThan(negation.precedence, operator)
+    ? (`(${negation.text})` as const)
+    : negation.text;
+
+const isLooserThan = (precedence: Precedence, operator: '&&' | '||'): boolean =>
+  precedence === 'looser' || (operator === '&&' && precedence === '||');
+
+const precedenceOf = (node: DeepReadonly<TSESTree.Node>): Precedence => {
+  if (node.type === AST_NODE_TYPES.LogicalExpression) {
+    // `??` cannot be mixed with `&&` or `||` without parentheses.
+    return node.operator === '??' ? 'looser' : node.operator;
+  }
+
+  return LOOSER_THAN_LOGICAL.has(node.type) ? 'looser' : 'tighter';
+};
+
+const LOOSER_THAN_LOGICAL: ReadonlySet<AST_NODE_TYPES> = new Set([
+  AST_NODE_TYPES.ArrowFunctionExpression,
+  AST_NODE_TYPES.AssignmentExpression,
+  AST_NODE_TYPES.ConditionalExpression,
+  AST_NODE_TYPES.SequenceExpression,
+  AST_NODE_TYPES.YieldExpression,
+]);
+
+/** Expressions `!` can be put in front of without parentheses. */
+const BINDS_AS_TIGHT_AS_UNARY: ReadonlySet<AST_NODE_TYPES> = new Set([
+  AST_NODE_TYPES.ArrayExpression,
+  AST_NODE_TYPES.AwaitExpression,
+  AST_NODE_TYPES.CallExpression,
+  AST_NODE_TYPES.ChainExpression,
+  AST_NODE_TYPES.Identifier,
+  AST_NODE_TYPES.Literal,
+  AST_NODE_TYPES.MemberExpression,
+  AST_NODE_TYPES.MetaProperty,
+  AST_NODE_TYPES.NewExpression,
+  AST_NODE_TYPES.ObjectExpression,
+  AST_NODE_TYPES.TaggedTemplateExpression,
+  AST_NODE_TYPES.TemplateLiteral,
+  AST_NODE_TYPES.ThisExpression,
+  AST_NODE_TYPES.TSNonNullExpression,
+  AST_NODE_TYPES.UnaryExpression,
+]);
+
+const RELATIONAL_OPERATORS: ReadonlySet<ComparisonOperator> =
+  new Set<ComparisonOperator>(['<', '<=', '>', '>=']);
+
+const constituentsOf = (type: ts.Type): readonly ts.Type[] =>
+  type.isUnion() ? type.types : ([type] as const);
+
+const isNeverNaN = (type: ts.Type, checker: ts.TypeChecker): boolean => {
+  // Read `ts.TypeFlags` here, not at module scope: every importer of this
+  // package's index evaluates the module, and a `typescript` without the JS
+  // API (7.x) would fail the import even for rules that never get here.
+  const neverNaNFlags =
+    ts.TypeFlags.NumberLiteral |
+    ts.TypeFlags.BigIntLike |
+    ts.TypeFlags.BooleanLike |
+    ts.TypeFlags.Null;
+
+  if ((type.flags & neverNaNFlags) !== 0) {
+    return true;
+  }
+
+  if (!type.isIntersection()) {
+    return false;
+  }
+
+  const brand = checker.getPropertyOfType(type, 'NaNValue');
+
+  if (brand === undefined) {
+    return false;
+  }
+
+  const brandType = checker.getTypeOfSymbol(brand);
+
+  return (
+    type.types.some(
+      (member) => (member.flags & ts.TypeFlags.NumberLike) !== 0,
+    ) &&
+    (brandType.flags & ts.TypeFlags.BooleanLiteral) !== 0 &&
+    checker.typeToString(brandType) === 'false'
+  );
+};
+
+/**
+ * The parser's node, which the source code and the token store take as
+ * mutable, for one that this package only reads.
+ */
+const asNode = <T extends TSESTree.Node>(node: DeepReadonly<T>): T =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  node as T;