@jameswyse/oxc-config 0.1.0 → 0.3.0

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" });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/shared/index.d.ts

@@ -23,4 +23,13 @@ export declare function projectPath(cwd: string, file: string): string;
 export declare function matchesAny(path: string, patterns?: readonly string[]): boolean;
 export declare function isGlobalValue(sourceCode: SourceCode, node: ESTree.Node | null | undefined, name: string): boolean;
 export declare function isInjectionSeam(source: ESTree.Node): boolean;
+export declare function isShortCircuited(call: ESTree.CallExpression): boolean;
+export declare function staticPropertyName(node: ESTree.Node): string | null;
+export declare function importedBinding(sourceCode: SourceCode, node: ESTree.Node): {
+    readonly source: string;
+    readonly name: string;
+} | null;
+export declare function isEffectModule(sourceCode: SourceCode, node: ESTree.Node, module: string): boolean;
+export declare function unwrapExpression(node: ESTree.Node): ESTree.Node;
+export declare function outermostExpression(node: ESTree.Node): ESTree.Node;
 export {};

package/dist/shared/index.js

@@ -258,3 +258,73 @@ export function isInjectionSeam(source) {
     }
     return false;
 }
+export function isShortCircuited(call) {
+    let current = call;
+    while (current.type === "CallExpression" || current.type === "MemberExpression") {
+        if (current.optional) {
+            return true;
+        }
+        current = current.type === "CallExpression" ? current.callee : current.object;
+        while (current.type === "TSNonNullExpression") {
+            current = current.expression;
+        }
+    }
+    return false;
+}
+export function staticPropertyName(node) {
+    if (!("computed" in node && node.computed)) {
+        return propertyName(node);
+    }
+    const key = memberKey(node);
+    return key?.type === "Literal" && typeof key.value === "string" ? key.value : null;
+}
+export function importedBinding(sourceCode, node) {
+    if (node.type === "MemberExpression") {
+        const owner = importedBinding(sourceCode, node.object);
+        const name = staticPropertyName(node);
+        return (owner?.name === "*" || owner?.name === "default") && name !== null
+            ? { source: owner.source, name }
+            : null;
+    }
+    const definition = variableFor(sourceCode, node)?.defs[0];
+    const declaration = definition?.parent;
+    if (definition?.type !== "ImportBinding" || declaration?.type !== "ImportDeclaration") {
+        return null;
+    }
+    const specifier = definition.node;
+    const source = declaration.source.value;
+    if (specifier.type === "ImportNamespaceSpecifier") {
+        return { source, name: "*" };
+    }
+    if (specifier.type === "ImportDefaultSpecifier") {
+        return { source, name: "default" };
+    }
+    return specifier.type === "ImportSpecifier"
+        ? {
+            source,
+            name: specifier.imported.type === "Identifier"
+                ? specifier.imported.name
+                : specifier.imported.value,
+        }
+        : null;
+}
+export function isEffectModule(sourceCode, node, module) {
+    const binding = importedBinding(sourceCode, node);
+    return ((binding?.source === "effect" && binding.name === module) ||
+        (binding?.source === `effect/${module}` && binding.name === "*"));
+}
+export function unwrapExpression(node) {
+    return node.type === "ParenthesizedExpression" ||
+        node.type === "TSAsExpression" ||
+        node.type === "TSSatisfiesExpression" ||
+        node.type === "TSNonNullExpression" ||
+        node.type === "TSTypeAssertion"
+        ? unwrapExpression(node.expression)
+        : node;
+}
+export function outermostExpression(node) {
+    const parent = node.parent;
+    return parent !== null && unwrapExpression(parent) === unwrapExpression(node)
+        ? outermostExpression(parent)
+        : node;
+}

package/dist/vendor/anti-slop/effect/rules/no-service-constructor-imports.js

@@ -11,11 +11,16 @@ function getImportedName(specifier) {
     }
     return specifier.imported.value;
 }
+function isCallOrTypeQuery(reference) {
+    const parent = reference.identifier.parent;
+    return (parent.type === "TSTypeQuery" ||
+        (parent.type === "CallExpression" && parent.callee === reference.identifier));
+}
 export const noServiceConstructorImports = defineRule({
     meta: {
         type: "problem",
         docs: {
-            description: "Disallow project-local make<CapabilityName> imports outside test and spec files.",
+            description: "Disallow project-local make<CapabilityName> service values imported outside test and spec files.",
         },
         messages: {
             serviceConstructorImport: 'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.',
@@ -33,7 +38,10 @@ export const noServiceConstructorImports = defineRule({
                         continue;
                     }
                     const importedName = getImportedName(specifier);
-                    if (!SERVICE_CONSTRUCTOR_NAME.test(importedName)) {
+                    if (!SERVICE_CONSTRUCTOR_NAME.test(importedName) ||
+                        context.sourceCode
+                            .getDeclaredVariables(specifier)
+                            .every((variable) => variable.references.every(isCallOrTypeQuery))) {
                         continue;
                     }
                     context.report({

package/dist/vendor/anti-slop/rules/no-known-value-widening.js

@@ -210,7 +210,7 @@ export const noKnownValueWidening = defineRule({
             description: "Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence.",
         },
         messages: {
-            widening: "The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract.",
+            widening: "The explicit {{target}} type on {{subject}} discards what the value already proves. Keep the inferred type, check it with `satisfies`, or annotate it with the named type its owner exports.",
         },
     },
     createOnce(context) {

package/dist/vendor/anti-slop/rules/no-module-mocking.js

@@ -1,5 +1,6 @@
 // Adapted from dmmulroy/anti-slop
 import { defineRule } from "@oxlint/plugins";
+import { apiReference, outermostExpression, propertyName } from "../../../shared/index.js";
 import { resolveVariable } from "../shared/scope.js";
 const moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
 function importedName(node) {
@@ -26,13 +27,67 @@ function isTestFrameworkObject(sourceCode, expression) {
         }
         const source = definition.parent.source.value;
         const name = importedName(definition.node);
-        return ((source === "vitest" && name === "vi") || (source === "@jest/globals" && name === "jest"));
+        return (((source === "vitest" || source === "@effect/vitest") && name === "vi") ||
+            (source === "@jest/globals" && name === "jest"));
     });
 }
+const nodeTestModules = ["node:test", "test"];
+const nodeTestContextMethods = new Set(["test", "before", "after", "beforeEach", "afterEach"]);
+function callbackCalls(sourceCode, callback) {
+    const argument = outermostExpression(callback);
+    const declarator = argument.parent;
+    const holder = callback.type === "FunctionDeclaration"
+        ? callback
+        : declarator?.type === "VariableDeclarator" && declarator.init === argument
+            ? declarator
+            : null;
+    const uses = holder === null
+        ? [argument]
+        : sourceCode
+            .getDeclaredVariables(holder)
+            .flatMap((variable) => variable.references.map((reference) => outermostExpression(reference.identifier)));
+    return uses.flatMap((use) => use.parent?.type === "CallExpression" && use.parent.arguments.some((item) => item === use)
+        ? [use.parent]
+        : []);
+}
+function isNodeTestContext(sourceCode, node) {
+    const definition = resolveVariable(sourceCode, node)?.defs[0];
+    const callback = definition?.type === "Parameter" ? definition.node : null;
+    if (callback === null || !("params" in callback) || callback.params[0] !== definition?.name) {
+        return false;
+    }
+    return callbackCalls(sourceCode, callback).some(({ callee }) => nodeTestModules.includes(apiReference(sourceCode, callee)?.module ?? "") ||
+        (callee.type === "MemberExpression" &&
+            callee.object.type === "Identifier" &&
+            nodeTestContextMethods.has(propertyName(callee) ?? "") &&
+            isNodeTestContext(sourceCode, callee.object)));
+}
+function isNodeTestMock(sourceCode, expression) {
+    if (expression.type === "MemberExpression") {
+        return (!expression.computed &&
+            expression.property.type === "Identifier" &&
+            expression.property.name === "mock" &&
+            expression.object.type === "Identifier" &&
+            isNodeTestContext(sourceCode, expression.object));
+    }
+    if (expression.type !== "Identifier") {
+        return false;
+    }
+    return (resolveVariable(sourceCode, expression)?.defs.some((definition) => definition.type === "ImportBinding" &&
+        definition.parent?.type === "ImportDeclaration" &&
+        nodeTestModules.includes(definition.parent.source.value) &&
+        importedName(definition.node) === "mock") ?? false);
+}
 function moduleMockCall(sourceCode, callee) {
     if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) {
         return false;
     }
+    if (!callee.computed &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "module" &&
+        isNodeTestMock(sourceCode, callee.object)) {
+        return true;
+    }
     if (!isTestFrameworkObject(sourceCode, callee.object)) {
         return false;
     }

package/dist/vendor/anti-slop/rules/no-runtime-typeof.js

@@ -1,5 +1,7 @@
 // Adapted from dmmulroy/anti-slop
 import { defineRule } from "@oxlint/plugins";
+import { variableFor } from "../../../shared/index.js";
+import { createTypeAliasEnvironment, resolvedTypeMatches, } from "../shared/type-alias-resolution.js";
 function isRuntimeFunction(node) {
     return (node.type === "ArrowFunctionExpression" ||
         node.type === "FunctionDeclaration" ||
@@ -26,6 +28,24 @@ function isExistenceProbe(node) {
     const other = parent.left === node ? parent.right : parent.left;
     return other.type === "Literal" && other.value === "undefined";
 }
+function declaredType(sourceCode, node) {
+    const name = variableFor(sourceCode, node)?.defs[0]?.name;
+    return name?.type === "Identifier" ? (name.typeAnnotation?.typeAnnotation ?? null) : null;
+}
+function isUnion(type, environment) {
+    return resolvedTypeMatches(type, environment, (resolved, matches) => resolved.type === "TSParenthesizedType"
+        ? matches(resolved.typeAnnotation)
+        : resolved.type === "TSUnionType");
+}
+function isOpen(type, environment) {
+    return resolvedTypeMatches(type, environment, (resolved, matches) => resolved.type === "TSUnknownKeyword" ||
+        resolved.type === "TSAnyKeyword" ||
+        (resolved.type === "TSParenthesizedType" && matches(resolved.typeAnnotation)) ||
+        (resolved.type === "TSUnionType" && resolved.types.some(matches)));
+}
+function isKnownUnion(type, environment) {
+    return isUnion(type, environment) && !isOpen(type, environment);
+}
 export const noRuntimeTypeof = defineRule({
     meta: {
         type: "problem",
@@ -33,7 +53,7 @@ export const noRuntimeTypeof = defineRule({
             description: "Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary.",
         },
         messages: {
-            runtimeTypeof: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value.",
+            runtimeTypeof: "A `typeof` check narrows a value's representation without proving its shape. Parse input where it enters, then branch on the domain value.",
         },
         schema: [
             {
@@ -45,7 +65,15 @@ export const noRuntimeTypeof = defineRule({
         defaultOptions: [{ allowInTypeGuards: false }],
     },
     createOnce(context) {
+        let environment = null;
+        function discriminatesKnownUnion(node) {
+            const type = declaredType(context.sourceCode, node.argument);
+            return type !== null && environment !== null && isKnownUnion(type, environment);
+        }
         return {
+            Program(program) {
+                environment = createTypeAliasEnvironment(program, context.sourceCode.visitorKeys);
+            },
             UnaryExpression(node) {
                 const option = context.options[0];
                 const allowInTypeGuards = typeof option === "object" &&
@@ -54,6 +82,7 @@ export const noRuntimeTypeof = defineRule({
                     option.allowInTypeGuards === true;
                 if (node.operator === "typeof" &&
                     !isExistenceProbe(node) &&
+                    !discriminatesKnownUnion(node) &&
                     (!allowInTypeGuards || !isInsideTypeGuard(node))) {
                     context.report({ node, messageId: "runtimeTypeof" });
                 }

package/dist/vendor/anti-slop/rules/no-shape-in-symbol-names.js

@@ -1,5 +1,6 @@
 // Adapted from dmmulroy/anti-slop
 import { defineRule } from "@oxlint/plugins";
+import { variableFor } from "../../../shared/index.js";
 const FORBIDDEN_SYMBOL_NAME = "shape";
 function containsForbiddenSymbolName(name) {
     return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
@@ -11,6 +12,30 @@ function isBorrowedMemberName(node) {
     }
     return parent.property === node && !parent.computed;
 }
+function importedName(specifier) {
+    return specifier.imported.type === "Identifier"
+        ? specifier.imported.name
+        : specifier.imported.value;
+}
+function isPackageImport(specifier) {
+    return (specifier.type === "ImportSpecifier" &&
+        specifier.parent.type === "ImportDeclaration" &&
+        !/^(?:\.{1,2}\/|@\/|~\/|#)/u.test(specifier.parent.source.value));
+}
+function isBorrowedImportName(sourceCode, node) {
+    const parent = node.parent;
+    if (parent?.type === "ImportSpecifier" && parent.imported === node) {
+        return isPackageImport(parent);
+    }
+    const variable = variableFor(sourceCode, node);
+    const definition = variable?.defs[0];
+    const specifier = definition?.type === "ImportBinding" ? definition.node : null;
+    return (specifier !== null &&
+        isPackageImport(specifier) &&
+        importedName(specifier) === node.name &&
+        (definition?.name === node ||
+            (variable?.references.some((reference) => reference.identifier === node) ?? false)));
+}
 export const noForbiddenTermInSymbolNames = defineRule({
     meta: {
         type: "problem",
@@ -23,7 +48,9 @@ export const noForbiddenTermInSymbolNames = defineRule({
     },
     createOnce(context) {
         const reportForbiddenSymbolName = (node) => {
-            if (!containsForbiddenSymbolName(node.name) || isBorrowedMemberName(node)) {
+            if (!containsForbiddenSymbolName(node.name) ||
+                isBorrowedMemberName(node) ||
+                isBorrowedImportName(context.sourceCode, node)) {
                 return;
             }
             context.report({ node, messageId: "forbiddenSymbolName", data: { name: node.name } });

package/dist/vendor/anti-slop/rules/no-unknown-returns.js

@@ -5,7 +5,7 @@ export const noUnknownReturns = defineRule({
     meta: {
         type: "problem",
         docs: {
-            description: "Disallow functions whose explicit return contract is unknown or Promise<unknown>.",
+            description: "Disallow functions whose declared return type is unknown or Promise<unknown>.",
         },
         messages: {
             unknownReturn: "This function exposes `unknown` to its caller. Parse the value at its boundary and return a named domain type.",

package/dist/vendor/anti-slop/rules/no-unsafe-dictionary-type.js

@@ -101,10 +101,10 @@ export const noUnsafeDictionaryType = defineRule({
     meta: {
         type: "problem",
         docs: {
-            description: "Disallow object-dictionary contracts whose direct value type is unknown, any, object, {}, or a union/alias containing one of those escape hatches.",
+            description: "Disallow dictionary types whose value type is unknown, any, object, {}, or a union or alias containing one of them.",
         },
         messages: {
-            unsafeDictionary: "This dictionary's {{value}} value type gives callers no concrete value contract. Use an owner/schema-derived value type; parse external payloads before insertion.",
+            unsafeDictionary: "This dictionary's {{value}} value type tells callers nothing about its values. Use the owner's or schema's value type, and parse external payloads before inserting them.",
         },
     },
     createOnce(context) {