@jameswyse/oxc-config 0.2.0 → 0.3.0

package/dist/rules/no-secret-fallback.js

@@ -0,0 +1,64 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobal, staticPropertyName, unwrapExpression } from "../shared/index.js";
+const secretName = /(?:SECRET|TOKEN|PASSWORD|PASSPHRASE|PRIVATE|CREDENTIAL|SALT|SIGNING|API_?KEY|ACCESS_?KEY|_KEY$|^KEY$)/iu;
+function isEnvironment(sourceCode, node) {
+    const environment = unwrapExpression(node);
+    if (environment.type !== "MemberExpression" || staticPropertyName(environment) !== "env") {
+        return false;
+    }
+    return (isGlobal(sourceCode, unwrapExpression(environment.object), "process") ||
+        (environment.object.type === "MetaProperty" && environment.object.property.name === "meta"));
+}
+function secretRead(sourceCode, node) {
+    const read = unwrapExpression(node);
+    const name = read.type === "MemberExpression" ? staticPropertyName(read) : null;
+    return read.type === "MemberExpression" &&
+        name !== null &&
+        secretName.test(name) &&
+        isEnvironment(sourceCode, read.object)
+        ? name
+        : null;
+}
+function isLiteralFallback(node) {
+    const fallback = unwrapExpression(node);
+    return ((fallback.type === "Literal" && typeof fallback.value === "string") ||
+        (fallback.type === "TemplateLiteral" && fallback.expressions.length === 0));
+}
+export const noSecretFallback = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Disallow literal fallbacks for secret environment variables." },
+        schema: [],
+        messages: {
+            fallback: "`{{name}}` falls back to a value written in the source, so a missing secret silently becomes a known one. Fail at startup when it is missing.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            LogicalExpression(node) {
+                const name = node.operator === "&&" ? null : secretRead(sourceCode, node.left);
+                if (name !== null && isLiteralFallback(node.right)) {
+                    context.report({ node, messageId: "fallback", data: { name } });
+                }
+            },
+            VariableDeclarator(node) {
+                if (node.id.type !== "ObjectPattern" ||
+                    node.init === null ||
+                    !isEnvironment(sourceCode, node.init)) {
+                    return;
+                }
+                for (const property of node.id.properties) {
+                    const name = property.type === "Property" ? staticPropertyName(property) : null;
+                    if (property.type === "Property" &&
+                        name !== null &&
+                        secretName.test(name) &&
+                        property.value.type === "AssignmentPattern" &&
+                        isLiteralFallback(property.value.right)) {
+                        context.report({ node: property, messageId: "fallback", data: { name } });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-swallowed-errors.js

@@ -1,5 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
-import { childNodes, isGlobal, propertyName, variableFor } from "../shared/index.js";
+import { childNodes, isEffectModule, isGlobal, propertyName, unwrapExpression, variableFor, } from "../shared/index.js";
 const nestedScopes = new Set([
     "ArrowFunctionExpression",
     "FunctionExpression",
@@ -109,14 +109,31 @@ function onlyProbes(sourceCode, block) {
         nodes.every((node) => (node.type !== "AwaitExpression" && node.type !== "YieldExpression") ||
             (node.argument !== null && containsProbe(sourceCode, node.argument))));
 }
-function isExistingPromise(node) {
+function isSharedBinding(sourceCode, node) {
+    const variable = variableFor(sourceCode, node);
+    return (variable === null ||
+        variable.defs.some((definition) => definition.type !== "Variable") ||
+        variable.references.filter((reference) => reference.isRead()).length > 1);
+}
+function storedValue(sourceCode, node) {
+    const value = unwrapExpression(node);
+    const declarator = value.type === "Identifier" ? variableFor(sourceCode, value)?.defs[0]?.node : undefined;
+    return declarator?.type === "VariableDeclarator" &&
+        declarator.parent.type === "VariableDeclaration" &&
+        declarator.parent.kind === "const" &&
+        declarator.init !== null
+        ? unwrapExpression(declarator.init)
+        : value;
+}
+function isExistingPromise(sourceCode, node) {
     const value = node.type === "ChainExpression" ? node.expression : node;
     if (value.type === "CallExpression" &&
         value.callee.type === "MemberExpression" &&
         propertyName(value.callee) === "finally") {
-        return isExistingPromise(value.callee.object);
+        return isExistingPromise(sourceCode, value.callee.object);
     }
-    return value.type === "Identifier" || value.type === "MemberExpression";
+    return ((value.type === "Identifier" && isSharedBinding(sourceCode, value)) ||
+        value.type === "MemberExpression");
 }
 function swallowingCallback(sourceCode, callback) {
     if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") {
@@ -128,13 +145,94 @@ function swallowingCallback(sourceCode, callback) {
     }
     return body.body.length === 0 || returnsFallback(sourceCode, body.body);
 }
+function rejectionHandler(node) {
+    if (node.callee.type !== "MemberExpression") {
+        return null;
+    }
+    const name = propertyName(node.callee);
+    const [onFulfilled, onRejected, ...extraArguments] = node.arguments;
+    const handler = name === "catch" && onRejected === undefined
+        ? onFulfilled
+        : name === "then" && extraArguments.length === 0
+            ? onRejected
+            : undefined;
+    return handler === undefined ? null : { promise: node.callee.object, handler };
+}
+const effectRecoveries = new Set(["catchAll", "catchAllCause", "orElse"]);
+function effectMember(sourceCode, node) {
+    return node.type === "MemberExpression" && isEffectModule(sourceCode, node.object, "Effect")
+        ? propertyName(node)
+        : null;
+}
+function isEffectFallback(sourceCode, node) {
+    const value = unwrap(node);
+    if (value === null) {
+        return false;
+    }
+    const member = effectMember(sourceCode, value);
+    if (member === "void" || member === "succeedNone") {
+        return true;
+    }
+    if (value.type !== "CallExpression" || effectMember(sourceCode, value.callee) !== "succeed") {
+        return false;
+    }
+    const [result] = value.arguments;
+    return (result === undefined || (result.type !== "SpreadElement" && isFallback(sourceCode, result)));
+}
+function returnedValue(callback) {
+    if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") {
+        return undefined;
+    }
+    const body = callback.body;
+    if (body === null) {
+        return undefined;
+    }
+    if (body.type !== "BlockStatement") {
+        return body;
+    }
+    const [statement] = body.body;
+    return body.body.length === 1 && statement?.type === "ReturnStatement"
+        ? statement.argument
+        : undefined;
+}
+function swallowingEffectRecovery(sourceCode, node) {
+    const name = effectMember(sourceCode, node.callee);
+    const handler = node.arguments.at(-1);
+    if (name === null || handler === undefined) {
+        return null;
+    }
+    const value = returnedValue(handler);
+    if (value === undefined) {
+        return null;
+    }
+    if (name === "orElseSucceed") {
+        return isFallback(sourceCode, value) ? handler : null;
+    }
+    return effectRecoveries.has(name) && isEffectFallback(sourceCode, value) ? handler : null;
+}
+function settlement(sourceCode, expression) {
+    let value = expression;
+    while (value.type === "AwaitExpression" ||
+        (value.type === "UnaryExpression" && value.operator === "void")) {
+        value = value.argument;
+    }
+    return value.type === "CallExpression" &&
+        value.callee.type === "MemberExpression" &&
+        propertyName(value.callee) === "allSettled" &&
+        isGlobal(sourceCode, value.callee.object, "Promise")
+        ? value
+        : null;
+}
 export const noSwallowedErrors = defineRule({
     meta: {
         type: "suggestion",
-        docs: { description: "Disallow catch handlers that discard the error and return a fallback." },
+        docs: {
+            description: "Disallow error handlers that discard the error and return a fallback, and unread settled results.",
+        },
         schema: [],
         messages: {
             swallowed: "This handler discards the error and returns a fallback, so callers cannot tell failure from an empty result. Prevent the failure, let it propagate, or return a failure the caller must handle.",
+            settled: "These settled results are never read, so every rejection disappears. Handle the rejected results, or use `Promise.all` so failures propagate.",
         },
     },
     create(context) {
@@ -149,18 +247,35 @@ export const noSwallowedErrors = defineRule({
                 }
             },
             CallExpression(node) {
-                const [callback, ...extraArguments] = node.arguments;
-                if (node.callee.type !== "MemberExpression" ||
-                    propertyName(node.callee) !== "catch" ||
-                    callback === undefined ||
-                    extraArguments.length > 0) {
-                    return;
+                const rejection = rejectionHandler(node);
+                if (rejection !== null &&
+                    !isExistingPromise(sourceCode, rejection.promise) &&
+                    !isProbe(sourceCode, storedValue(sourceCode, rejection.promise)) &&
+                    swallowingCallback(sourceCode, rejection.handler)) {
+                    context.report({ node: rejection.handler, messageId: "swallowed" });
                 }
-                const promise = node.callee.object;
-                if (!isExistingPromise(promise) &&
-                    !isProbe(sourceCode, promise) &&
-                    swallowingCallback(sourceCode, callback)) {
-                    context.report({ node: callback, messageId: "swallowed" });
+                const recovery = swallowingEffectRecovery(sourceCode, node);
+                if (recovery !== null) {
+                    context.report({ node: recovery, messageId: "swallowed" });
+                }
+            },
+            ExpressionStatement(node) {
+                const discarded = settlement(sourceCode, node.expression);
+                if (discarded !== null) {
+                    context.report({ node: discarded, messageId: "settled" });
+                }
+            },
+            VariableDeclarator(node) {
+                const voided = node.init?.type === "UnaryExpression" && node.init.operator === "void";
+                const unread = node.init === null || (!voided && node.parent.parent?.type === "ExportNamedDeclaration")
+                    ? null
+                    : settlement(sourceCode, node.init);
+                if (unread !== null &&
+                    (voided ||
+                        sourceCode
+                            .getDeclaredVariables(node)
+                            .every((variable) => !variable.references.some((reference) => reference.isRead())))) {
+                    context.report({ node: unread, messageId: "settled" });
                 }
             },
         };

package/dist/rules/no-test-timeout-overrides.js

@@ -1,5 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
-import { isGlobal, propertyName, apiReference, testModules } from "../shared/index.js";
+import { isGlobal, propertyName, apiReference, staticPropertyName, testModules, unwrapExpression, } from "../shared/index.js";
 const optionKeys = new Set(["timeout", "retry", "retries"]);
 const configKeys = new Set(["testTimeout", "hookTimeout", "retry"]);
 const hooks = new Set(["beforeEach", "afterEach", "beforeAll", "afterAll"]);
@@ -20,18 +20,27 @@ function testApi(sourceCode, callee) {
     }
     return null;
 }
+function isZero(node) {
+    const value = node === undefined ? undefined : unwrapExpression(node);
+    return value?.type === "Literal" && value.value === 0;
+}
 function hasOverrideKey(node, keys) {
-    return (node?.type === "ObjectExpression" &&
-        node.properties.some((property) => {
-            const name = property.type === "Property" ? propertyName(property) : null;
-            return name !== null && keys.has(name);
+    const options = node === undefined ? undefined : unwrapExpression(node);
+    return (options?.type === "ObjectExpression" &&
+        options.properties.some((property) => {
+            const name = property.type === "Property" ? staticPropertyName(property) : null;
+            return (property.type === "Property" &&
+                name !== null &&
+                keys.has(name) &&
+                !(name.startsWith("retr") && isZero(property.value)));
         }));
 }
 function timeoutArgument(node) {
-    return (node !== undefined &&
-        node.type !== "ObjectExpression" &&
-        node.type !== "SpreadElement" &&
-        !functionTypes.has(node.type));
+    const value = node === undefined ? undefined : unwrapExpression(node);
+    return (value !== undefined &&
+        value.type !== "ObjectExpression" &&
+        value.type !== "SpreadElement" &&
+        !functionTypes.has(value.type));
 }
 function registrationOverride(sourceCode, node) {
     const name = testApi(sourceCode, node.callee);
@@ -72,6 +81,10 @@ function runnerOverride(sourceCode, node) {
         return (runnerObject(sourceCode, callee.object, "jest", ["@jest/globals"]) ||
             importedTest(sourceCode, callee.object));
     }
+    if (method === "retryTimes") {
+        return (runnerObject(sourceCode, callee.object, "jest", ["@jest/globals"]) &&
+            !isZero(node.arguments[0]));
+    }
     if (method === "slow") {
         return importedTest(sourceCode, callee.object);
     }

package/dist/rules/no-unchecked-fetch-response.d.ts

@@ -0,0 +1 @@
+export declare const noUncheckedFetchResponse: import("@oxlint/plugins").Rule;

package/dist/rules/no-unchecked-fetch-response.js

@@ -0,0 +1,91 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobal, isGlobalValue, outermostExpression, staticPropertyName, unwrapExpression, } from "../shared/index.js";
+const bodyReaders = new Set(["json", "text", "arrayBuffer", "blob", "formData", "bytes"]);
+const statusChecks = new Set(["ok", "status"]);
+const metadata = new Set(["headers", "url", "redirected", "type"]);
+function unwrap(node) {
+    const value = unwrapExpression(node);
+    return value.type === "AwaitExpression" ? unwrap(value.argument) : value;
+}
+function isFetch(sourceCode, node) {
+    const value = node === null ? null : unwrap(node);
+    return value?.type === "CallExpression" && isGlobalValue(sourceCode, value.callee, "fetch");
+}
+function isLogged(sourceCode, node) {
+    const position = node.parent;
+    return (position?.type === "TemplateLiteral" ||
+        (position?.type === "CallExpression" &&
+            position.arguments.some((argument) => argument === node) &&
+            position.callee.type === "MemberExpression" &&
+            isGlobal(sourceCode, position.callee.object, "console")));
+}
+function use(sourceCode, reference) {
+    const response = outermostExpression(reference.identifier);
+    const member = response.parent;
+    if (member?.type !== "MemberExpression" || member.object !== response) {
+        return "other";
+    }
+    const name = staticPropertyName(member);
+    if (name !== null && statusChecks.has(name)) {
+        return isLogged(sourceCode, outermostExpression(member)) ? "metadata" : "check";
+    }
+    if (name !== null && metadata.has(name)) {
+        return "metadata";
+    }
+    return name !== null &&
+        bodyReaders.has(name) &&
+        member.parent.type === "CallExpression" &&
+        member.parent.callee === member
+        ? "body"
+        : "other";
+}
+function readsBodyUnchecked(sourceCode, variables) {
+    const uses = variables.flatMap((variable) => variable.references
+        .filter((reference) => reference.isRead())
+        .map((reference) => use(sourceCode, reference)));
+    return uses.includes("body") && uses.every((item) => item === "body" || item === "metadata");
+}
+export const noUncheckedFetchResponse = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Require a status check before reading a fetch response body." },
+        schema: [],
+        messages: {
+            unchecked: "This reads the response body without checking `ok` or `status`, so an error response is treated as data. Check the status first.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            VariableDeclarator(node) {
+                if (node.id.type === "Identifier" &&
+                    isFetch(sourceCode, node.init) &&
+                    readsBodyUnchecked(sourceCode, sourceCode.getDeclaredVariables(node))) {
+                    context.report({ node, messageId: "unchecked" });
+                }
+            },
+            CallExpression(node) {
+                const member = node.callee;
+                const name = member.type === "MemberExpression" ? staticPropertyName(member) : null;
+                if (member.type !== "MemberExpression" || name === null) {
+                    return;
+                }
+                if (bodyReaders.has(name) && isFetch(sourceCode, member.object)) {
+                    context.report({ node, messageId: "unchecked" });
+                    return;
+                }
+                const [callback] = node.arguments;
+                if (name === "then" &&
+                    isFetch(sourceCode, member.object) &&
+                    (callback?.type === "ArrowFunctionExpression" ||
+                        callback?.type === "FunctionExpression") &&
+                    callback.params[0]?.type === "Identifier" &&
+                    readsBodyUnchecked(sourceCode, sourceCode
+                        .getDeclaredVariables(callback)
+                        .filter((variable) => variable.defs.some((definition) => definition.type === "Parameter")))) {
+                    context.report({ node: callback, messageId: "unchecked" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-unchecked-index-search.d.ts

@@ -0,0 +1 @@
+export declare const noUncheckedIndexSearch: import("@oxlint/plugins").Rule;

package/dist/rules/no-unchecked-index-search.js

@@ -0,0 +1,41 @@
+import { defineRule } from "@oxlint/plugins";
+import { staticPropertyName, unwrapExpression } from "../shared/index.js";
+const searches = new Set(["indexOf", "lastIndexOf", "findIndex", "findLastIndex"]);
+const indexedArguments = new Map([
+    ["splice", 1],
+    ["toSpliced", 1],
+    ["with", 1],
+    ["at", 1],
+    ["slice", 2],
+]);
+function searchCall(node) {
+    const call = unwrapExpression(node);
+    const name = call.type === "CallExpression" && call.callee.type === "MemberExpression"
+        ? staticPropertyName(call.callee)
+        : null;
+    return name !== null && searches.has(name) ? name : null;
+}
+export const noUncheckedIndexSearch = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Require a missing-item check before using a searched index." },
+        schema: [],
+        messages: {
+            unchecked: "`{{search}}` returns -1 when nothing matches, and here -1 counts from the end, so a missing item silently targets the last element. Store the index and handle -1 first.",
+        },
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                const method = node.callee.type === "MemberExpression" ? staticPropertyName(node.callee) : null;
+                const count = method === null ? undefined : indexedArguments.get(method);
+                for (const argument of node.arguments.slice(0, count ?? 0)) {
+                    const search = searchCall(argument);
+                    if (search !== null) {
+                        context.report({ node: argument, messageId: "unchecked", data: { search } });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-uncontrolled-test-clock.d.ts

@@ -0,0 +1 @@
+export declare const noUncontrolledTestClock: import("@oxlint/plugins").Rule;

package/dist/rules/no-uncontrolled-test-clock.js

@@ -0,0 +1,112 @@
+import { defineRule } from "@oxlint/plugins";
+import { importedBinding, isGlobalValue, isPlaywright, staticPropertyName, testContext, unwrapExpression, variableFor, } from "../shared/index.js";
+const fakeClockMethods = new Set(["install", "setFixedTime"]);
+const timerLists = new Set(["apis", "toFake", "doNotFake"]);
+function nameOf(node) {
+    const value = unwrapExpression(node);
+    return value.type === "Identifier" ? value.name : staticPropertyName(value);
+}
+function fakesDate(options) {
+    const value = options === undefined ? undefined : unwrapExpression(options);
+    if (value?.type !== "ObjectExpression") {
+        return true;
+    }
+    return value.properties.every((property) => {
+        const name = property.type === "Property" ? staticPropertyName(property) : null;
+        const list = property.type === "Property" ? unwrapExpression(property.value) : null;
+        if (name === null || !timerLists.has(name) || list?.type !== "ArrayExpression") {
+            return true;
+        }
+        const values = list.elements.map((element) => element?.type === "Literal" ? element.value : undefined);
+        if (values.length === 0 || values.includes(undefined)) {
+            return true;
+        }
+        return name === "doNotFake" ? !values.includes("Date") : values.includes("Date");
+    });
+}
+function isNodeMock(sourceCode, node) {
+    const binding = importedBinding(sourceCode, unwrapExpression(node));
+    return nameOf(node) === "mock" || (binding?.source === "node:test" && binding.name === "mock");
+}
+function isLocalFunction(sourceCode, node) {
+    const definition = variableFor(sourceCode, node)?.defs[0];
+    return definition !== undefined && definition.type !== "ImportBinding";
+}
+function controlsClock(sourceCode, call) {
+    const callee = unwrapExpression(call.callee);
+    const name = isLocalFunction(sourceCode, callee) ? null : nameOf(callee);
+    if (name === "setSystemTime") {
+        return true;
+    }
+    if (name === "useFakeTimers") {
+        return fakesDate(call.arguments[0]);
+    }
+    if (name === null || callee.type !== "MemberExpression") {
+        return false;
+    }
+    const owner = unwrapExpression(callee.object);
+    return ((nameOf(owner) === "clock" && fakeClockMethods.has(name)) ||
+        (name === "enable" &&
+            owner.type === "MemberExpression" &&
+            nameOf(owner) === "timers" &&
+            isNodeMock(sourceCode, owner.object) &&
+            fakesDate(call.arguments[0])));
+}
+export const noUncontrolledTestClock = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Require tests that read the current time to control the clock." },
+        schema: [],
+        messages: {
+            clock: "This test reads the real clock, so its result depends on when it runs. Use a fixed date, or control time with fake timers.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const drivesBrowser = sourceCode.ast.body.some((statement) => statement.type === "ImportDeclaration" && isPlaywright(statement.source.value));
+        if (drivesBrowser) {
+            return {};
+        }
+        const reads = [];
+        const controlledTests = new Set();
+        let controlledFile = false;
+        function enclosingTest(node) {
+            const test = testContext(sourceCode, node);
+            return test?.api.name === "test" || test?.api.name === "it" ? test.callback : null;
+        }
+        return {
+            CallExpression(node) {
+                if (controlsClock(sourceCode, node)) {
+                    const test = enclosingTest(node);
+                    if (test === null) {
+                        controlledFile = true;
+                    }
+                    else {
+                        controlledTests.add(test);
+                    }
+                }
+                if (node.callee.type === "MemberExpression" &&
+                    staticPropertyName(node.callee) === "now" &&
+                    isGlobalValue(sourceCode, node.callee.object, "Date")) {
+                    reads.push(node);
+                }
+            },
+            NewExpression(node) {
+                if (node.arguments.length === 0 && isGlobalValue(sourceCode, node.callee, "Date")) {
+                    reads.push(node);
+                }
+            },
+            "Program:exit"() {
+                if (controlledFile) {
+                    return;
+                }
+                for (const node of reads) {
+                    const test = enclosingTest(node);
+                    if (test === null || !controlledTests.has(test)) {
+                        context.report({ node, messageId: "clock" });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-unsettled-promise.d.ts

@@ -0,0 +1 @@
+export declare const noUnsettledPromise: import("@oxlint/plugins").Rule;

package/dist/rules/no-unsettled-promise.js

@@ -0,0 +1,64 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobal, isShortCircuited } from "../shared/index.js";
+function isOptionallyReached(reference, executor) {
+    let child = reference.identifier;
+    for (let node = child.parent; node !== null && node !== executor; child = node, node = node.parent) {
+        const argument = child;
+        if (node.type === "CallExpression" &&
+            node.arguments.some((candidate) => candidate === argument) &&
+            isShortCircuited(node)) {
+            return true;
+        }
+    }
+    return false;
+}
+function doesNothing(executor) {
+    const body = executor.body;
+    if (body?.type === "BlockStatement") {
+        return body.body.length === 0;
+    }
+    return ((body?.type === "Identifier" && body.name === "undefined") ||
+        (body?.type === "UnaryExpression" &&
+            body.operator === "void" &&
+            body.argument.type === "Literal"));
+}
+function endsByThrowing(executor) {
+    return (executor.body?.type === "BlockStatement" && executor.body.body.at(-1)?.type === "ThrowStatement");
+}
+export const noUnsettledPromise = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Require a Promise executor that runs code to settle the promise." },
+        schema: [],
+        messages: {
+            unsettled: "This executor never calls `resolve` or `reject`, so the promise never settles. Return the underlying promise instead, or settle it when the work finishes.",
+            optional: "This executor only settles inside an optional call, so the promise never settles when the target is missing. Settle it on both paths.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            NewExpression(node) {
+                const [executor] = node.arguments;
+                if (!isGlobal(sourceCode, node.callee, "Promise") ||
+                    (executor?.type !== "ArrowFunctionExpression" &&
+                        executor?.type !== "FunctionExpression") ||
+                    doesNothing(executor) ||
+                    endsByThrowing(executor) ||
+                    executor.params.some((parameter) => parameter.type !== "Identifier")) {
+                    return;
+                }
+                const references = sourceCode
+                    .getDeclaredVariables(executor)
+                    .filter((variable) => variable.defs.some((definition) => definition.type === "Parameter"))
+                    .flatMap((variable) => variable.references);
+                if (references.length === 0) {
+                    context.report({ node: executor, messageId: "unsettled" });
+                }
+                else if (references.every((reference) => isOptionallyReached(reference, executor))) {
+                    context.report({ node: executor, messageId: "optional" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/require-suppression-reason.d.ts

@@ -0,0 +1 @@
+export declare const requireSuppressionReason: import("@oxlint/plugins").Rule;

package/dist/rules/require-suppression-reason.js

@@ -0,0 +1,32 @@
+import { defineRule } from "@oxlint/plugins";
+const disableDirective = /^\s*(?:oxlint|eslint)-disable(?:-next-line|-line)?(?=\s|$)(?<rest>.*)$/su;
+export const requireSuppressionReason = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Require each lint suppression to name its rules and give a reason." },
+        schema: [],
+        messages: {
+            rule: "Name the rules this directive suppresses, so it can't hide other diagnostics.",
+            reason: "Give this suppression a reason after `--` that says why the reported code is correct here.",
+        },
+    },
+    create(context) {
+        return {
+            Program() {
+                for (const comment of context.sourceCode.getAllComments()) {
+                    const rest = disableDirective.exec(comment.value)?.groups?.["rest"];
+                    if (rest === undefined) {
+                        continue;
+                    }
+                    const [rules = "", reason = ""] = rest.split(/\s-{2,}(?:\s|$)/u, 2);
+                    if (rules.trim() === "") {
+                        context.report({ loc: comment.loc, messageId: "rule" });
+                    }
+                    else if (reason.trim() === "") {
+                        context.report({ loc: comment.loc, messageId: "reason" });
+                    }
+                }
+            },
+        };
+    },
+});