@commonplaces/oxlint-plugin 0.0.0-stage → 0.1.1

package/dist/anti-slop/shared/dictionary-types.js

@@ -0,0 +1,374 @@
+import { Array, HashMap, HashSet, Option } from "effect";
+const BUILT_INS = HashSet.fromIterable([
+    "Record",
+    "Readonly",
+    "Partial",
+    "Required",
+    "Pick",
+    "Omit",
+    "PropertyKey",
+    "NonNullable",
+]);
+const TRANSPARENT_WRAPPERS = HashSet.fromIterable([
+    "Readonly",
+    "Partial",
+    "Required",
+    "NonNullable",
+]);
+function declaredStatement(statement) {
+    return statement.type === "ExportNamedDeclaration" ||
+        statement.type === "ExportDefaultDeclaration"
+        ? (statement.declaration ?? null)
+        : statement;
+}
+export function createTypeEnvironment(program) {
+    const empty = {
+        aliases: HashMap.empty(),
+        interfaces: HashMap.empty(),
+        shadowedBuiltIns: HashSet.empty(),
+    };
+    return Array.reduce(program.body, empty, (environment, statement) => {
+        const declaration = declaredStatement(statement);
+        if (declaration?.type === "ImportDeclaration") {
+            return {
+                ...environment,
+                shadowedBuiltIns: HashSet.union(environment.shadowedBuiltIns, HashSet.fromIterable(Array.filter(Array.map(declaration.specifiers, (specifier) => specifier.local.name), (name) => HashSet.has(BUILT_INS, name)))),
+            };
+        }
+        if (declaration?.type === "TSTypeAliasDeclaration") {
+            const name = declaration.id.name;
+            const duplicate = HashMap.has(environment.aliases, name);
+            return {
+                ...environment,
+                aliases: duplicate
+                    ? environment.aliases
+                    : HashMap.set(environment.aliases, name, declaration),
+                shadowedBuiltIns: duplicate || HashSet.has(BUILT_INS, name)
+                    ? HashSet.add(environment.shadowedBuiltIns, name)
+                    : environment.shadowedBuiltIns,
+            };
+        }
+        if (declaration?.type === "TSInterfaceDeclaration") {
+            const name = declaration.id.name;
+            const declarations = Option.getOrElse(HashMap.get(environment.interfaces, name), () => []);
+            return {
+                ...environment,
+                interfaces: HashMap.set(environment.interfaces, name, [...declarations, declaration]),
+                shadowedBuiltIns: HashSet.has(BUILT_INS, name)
+                    ? HashSet.add(environment.shadowedBuiltIns, name)
+                    : environment.shadowedBuiltIns,
+            };
+        }
+        if ((declaration?.type === "TSEnumDeclaration" ||
+            declaration?.type === "ClassDeclaration" ||
+            declaration?.type === "FunctionDeclaration") &&
+            declaration.id !== null &&
+            HashSet.has(BUILT_INS, declaration.id.name)) {
+            return {
+                ...environment,
+                shadowedBuiltIns: HashSet.add(environment.shadowedBuiltIns, declaration.id.name),
+            };
+        }
+        return environment;
+    });
+}
+function typeReferenceName(type) {
+    return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isBuiltIn(name, environment) {
+    return HashSet.has(BUILT_INS, name) && !HashSet.has(environment.shadowedBuiltIns, name);
+}
+function isUnappliedReferenceTo(type, name) {
+    const unwrapped = unwrapTransparentType(type);
+    return (unwrapped.type === "TSTypeReference" &&
+        typeReferenceName(unwrapped) === name &&
+        (unwrapped.typeArguments === null ||
+            unwrapped.typeArguments === undefined ||
+            unwrapped.typeArguments.params.length === 0));
+}
+function unwrapTransparentType(type) {
+    const current = type;
+    if (current.type === "TSParenthesizedType" ||
+        (current.type === "TSTypeOperator" && current.operator === "readonly")) {
+        return unwrapTransparentType(current.typeAnnotation);
+    }
+    return current;
+}
+function isNeverType(type) {
+    return unwrapTransparentType(type).type === "TSNeverKeyword";
+}
+function isEffectivelyEmptyMember(member) {
+    return (member.type === "TSPropertySignature" &&
+        member.optional === true &&
+        member.typeAnnotation !== null &&
+        member.typeAnnotation !== undefined &&
+        isNeverType(member.typeAnnotation.typeAnnotation));
+}
+function isEffectivelyEmptyTypeLiteral(type) {
+    return type.members.length === 0 || Array.every(type.members, isEffectivelyEmptyMember);
+}
+function isEffectivelyEmptyInterface(declarations) {
+    if (declarations.length !== 1)
+        return false;
+    const [type] = declarations;
+    return (type !== undefined &&
+        type.extends.length === 0 &&
+        (type.body.body.length === 0 || Array.every(type.body.body, isEffectivelyEmptyMember)));
+}
+function resolvedSubstitutionArgument(type, base, resolving = HashSet.empty()) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type !== "TSTypeReference")
+        return type;
+    const name = typeReferenceName(unwrapped);
+    if (name === null || HashSet.has(resolving, name))
+        return type;
+    const substitution = Option.getOrUndefined(HashMap.get(base, name));
+    if (substitution === undefined)
+        return type;
+    const nextResolving = HashSet.add(resolving, name);
+    return resolvedSubstitutionArgument(substitution, base, nextResolving);
+}
+function aliasSubstitution(alias, type, base) {
+    const parameters = alias.typeParameters?.params ?? [];
+    const arguments_ = type.typeArguments?.params ?? [];
+    return Option.getOrNull(Array.reduce(parameters, Option.some(base), (result, parameter, index) => Option.flatMap(result, (next) => Option.fromNullishOr(Option.getOrUndefined(Array.get(arguments_, index)) ?? parameter.default).pipe(Option.map((argument) => HashMap.set(next, parameter.name.name, resolvedSubstitutionArgument(argument, next)))))));
+}
+function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSUnknownKeyword")
+        return "unknown";
+    if (unwrapped.type === "TSAnyKeyword")
+        return "any";
+    if (unwrapped.type === "TSObjectKeyword")
+        return "object";
+    if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped))
+        return "empty-object";
+    if (unwrapped.type === "TSUnionType") {
+        return Array.some(unwrapped.types, (member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases) !== null)
+            ? "union"
+            : null;
+    }
+    if (unwrapped.type === "TSIntersectionType") {
+        const unsafeMembers = Array.map(unwrapped.types, (member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases));
+        if (Array.contains(unsafeMembers, "any"))
+            return "any";
+        return unsafeMembers.length > 0 && Array.every(unsafeMembers, (member) => member !== null)
+            ? (Option.getOrUndefined(Array.head(unsafeMembers)) ?? null)
+            : null;
+    }
+    if (unwrapped.type !== "TSTypeReference")
+        return null;
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return null;
+    if (HashSet.has(TRANSPARENT_WRAPPERS, name) && isBuiltIn(name, environment)) {
+        const wrapped = Option.getOrUndefined(Array.head(unwrapped.typeArguments?.params ?? []));
+        return wrapped === undefined
+            ? null
+            : unsafeDirectValue(wrapped, environment, substitutions, resolvingAliases);
+    }
+    const substitution = Option.getOrUndefined(HashMap.get(substitutions, name));
+    if (substitution !== undefined) {
+        return isUnappliedReferenceTo(substitution, name)
+            ? null
+            : unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+    }
+    const interfaceDeclarations = Option.getOrUndefined(HashMap.get(environment.interfaces, name));
+    if (interfaceDeclarations !== undefined) {
+        return isEffectivelyEmptyInterface(interfaceDeclarations) ? "empty-object" : null;
+    }
+    const alias = Option.getOrUndefined(HashMap.get(environment.aliases, name));
+    if (alias === undefined || HashSet.has(resolvingAliases, name))
+        return null;
+    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    if (nextSubstitutions === null)
+        return null;
+    const nextResolving = HashSet.add(resolvingAliases, name);
+    return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function dictionaryValueTypes(type, environment, substitutions, resolvingAliases) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSTypeLiteral") {
+        return Array.flatMap(unwrapped.members, (member) => member.type === "TSIndexSignature" && member.typeAnnotation !== null
+            ? [{ type: member.typeAnnotation.typeAnnotation, substitutions }]
+            : []);
+    }
+    if (unwrapped.type === "TSMappedType") {
+        return unwrapped.typeAnnotation === null
+            ? []
+            : [{ type: unwrapped.typeAnnotation, substitutions }];
+    }
+    if (unwrapped.type !== "TSTypeReference")
+        return [];
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return [];
+    const substitution = Option.getOrUndefined(HashMap.get(substitutions, name));
+    if (substitution !== undefined) {
+        return isUnappliedReferenceTo(substitution, name)
+            ? []
+            : dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
+    }
+    if (HashSet.has(TRANSPARENT_WRAPPERS, name) && isBuiltIn(name, environment)) {
+        const wrapped = Option.getOrUndefined(Array.head(unwrapped.typeArguments?.params ?? []));
+        return wrapped === undefined
+            ? []
+            : dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases);
+    }
+    if (name === "Record" && isBuiltIn(name, environment)) {
+        const value = Option.getOrUndefined(Array.get(unwrapped.typeArguments?.params ?? [], 1)) ?? null;
+        return value === null ? [] : [{ type: value, substitutions }];
+    }
+    if ((name === "Pick" || name === "Omit") && isBuiltIn(name, environment)) {
+        const source = Option.getOrUndefined(Array.head(unwrapped.typeArguments?.params ?? []));
+        return source === undefined
+            ? []
+            : dictionaryValueTypes(source, environment, substitutions, resolvingAliases);
+    }
+    const alias = Option.getOrUndefined(HashMap.get(environment.aliases, name));
+    if (alias === undefined || HashSet.has(resolvingAliases, name))
+        return [];
+    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    if (nextSubstitutions === null)
+        return [];
+    const nextResolving = HashSet.add(resolvingAliases, name);
+    return dictionaryValueTypes(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+export function classifyUnsafeDictionaryValue(valueType, environment) {
+    const unsafeValue = unsafeDirectValue(valueType, environment, HashMap.empty(), HashSet.empty());
+    return unsafeValue === null ? null : { kind: "unsafe-dictionary", unsafeValue };
+}
+export function classifyUnsafeDictionary(type, environment) {
+    return Option.getOrNull(Array.findFirst(Array.map(dictionaryValueTypes(type, environment, HashMap.empty(), HashSet.empty()), (valueType) => Option.map(Option.fromNullishOr(unsafeDirectValue(valueType.type, environment, valueType.substitutions, HashSet.empty())), (unsafeValue) => ({ kind: "unsafe-dictionary", unsafeValue }))), Option.isSome).pipe(Option.flatten));
+}
+function resolvesToDictionary(type, environment, substitutions, resolvingAliases) {
+    return dictionaryValueTypes(type, environment, substitutions, resolvingAliases).length > 0;
+}
+export function classifyWideningTarget(type, environment) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSUnknownKeyword")
+        return { kind: "unknown" };
+    if (unwrapped.type === "TSObjectKeyword")
+        return { kind: "object" };
+    if (unwrapped.type === "TSTypeLiteral") {
+        return Array.some(unwrapped.members, (member) => member.type === "TSIndexSignature")
+            ? { kind: "open dictionary" }
+            : unwrapped.members.length > 0
+                ? { kind: "anonymous object" }
+                : null;
+    }
+    if (unwrapped.type === "TSMappedType")
+        return { kind: "open dictionary" };
+    if (unwrapped.type !== "TSTypeReference")
+        return null;
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return null;
+    if (HashSet.has(TRANSPARENT_WRAPPERS, name) && isBuiltIn(name, environment)) {
+        const wrapped = Option.getOrUndefined(Array.head(unwrapped.typeArguments?.params ?? []));
+        return wrapped === undefined ? null : classifyWideningTarget(wrapped, environment);
+    }
+    if (name === "Record" && isBuiltIn(name, environment))
+        return { kind: "open dictionary" };
+    const alias = Option.getOrUndefined(HashMap.get(environment.aliases, name));
+    if (alias === undefined)
+        return null;
+    if ((alias.typeParameters?.params.length ?? 0) > 0) {
+        const substitutions = aliasSubstitution(alias, unwrapped, HashMap.empty());
+        return substitutions !== null &&
+            resolvesToDictionary(alias.typeAnnotation, environment, substitutions, HashSet.fromIterable([name]))
+            ? { kind: "generic container" }
+            : null;
+    }
+    const substitutions = aliasSubstitution(alias, unwrapped, HashMap.empty());
+    if (substitutions === null)
+        return null;
+    const resolved = classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, HashSet.fromIterable([name]));
+    return resolved;
+}
+function isBroadMappedKey(type, environment, substitutions) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSStringKeyword" ||
+        unwrapped.type === "TSNumberKeyword" ||
+        unwrapped.type === "TSSymbolKeyword") {
+        return true;
+    }
+    if (unwrapped.type === "TSUnionType") {
+        return Array.every(unwrapped.types, (member) => isBroadMappedKey(member, environment, substitutions));
+    }
+    if (unwrapped.type !== "TSTypeReference")
+        return false;
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return false;
+    const substitution = Option.getOrUndefined(HashMap.get(substitutions, name));
+    if (substitution !== undefined && !isUnappliedReferenceTo(substitution, name)) {
+        return isBroadMappedKey(substitution, environment, substitutions);
+    }
+    return name === "PropertyKey" && isBuiltIn(name, environment);
+}
+function classifyAliasBroadTarget(type, environment, substitutions, resolvingAliases) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSUnknownKeyword")
+        return { kind: "unknown" };
+    if (unwrapped.type === "TSObjectKeyword")
+        return { kind: "object" };
+    if (unwrapped.type === "TSTypeLiteral") {
+        return Array.some(unwrapped.members, (member) => member.type === "TSIndexSignature")
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    if (unwrapped.type === "TSMappedType") {
+        return isBroadMappedKey(unwrapped.constraint, environment, substitutions)
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    if (unwrapped.type !== "TSTypeReference")
+        return null;
+    const name = typeReferenceName(unwrapped);
+    if (name === null)
+        return null;
+    const substitution = Option.getOrUndefined(HashMap.get(substitutions, name));
+    if (substitution !== undefined) {
+        return isUnappliedReferenceTo(substitution, name)
+            ? null
+            : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+    }
+    if (HashSet.has(TRANSPARENT_WRAPPERS, name) && isBuiltIn(name, environment)) {
+        const wrapped = Option.getOrUndefined(Array.head(unwrapped.typeArguments?.params ?? []));
+        return wrapped === undefined
+            ? null
+            : classifyAliasBroadTarget(wrapped, environment, substitutions, resolvingAliases);
+    }
+    if (name === "Record" && isBuiltIn(name, environment)) {
+        return { kind: "open dictionary" };
+    }
+    const alias = Option.getOrUndefined(HashMap.get(environment.aliases, name));
+    if (alias === undefined || HashSet.has(resolvingAliases, name))
+        return null;
+    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    if (nextSubstitutions === null)
+        return null;
+    const nextResolving = HashSet.add(resolvingAliases, name);
+    return classifyAliasBroadTarget(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+export function isKnownEvidenceExpression(expression) {
+    const current = expression;
+    if (current.type === "ParenthesizedExpression" ||
+        current.type === "TSAsExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "TSNonNullExpression" ||
+        current.type === "TSSatisfiesExpression") {
+        return isKnownEvidenceExpression(current.expression);
+    }
+    if (current.type === "ObjectExpression")
+        return true;
+    return (current.type === "ArrayExpression" ||
+        current.type === "ArrowFunctionExpression" ||
+        current.type === "ClassExpression" ||
+        current.type === "FunctionExpression" ||
+        current.type === "NewExpression" ||
+        current.type === "Literal" ||
+        current.type === "TemplateLiteral" ||
+        current.type === "UnaryExpression");
+}

package/dist/anti-slop/shared/lexical-type-parameters.d.ts

@@ -0,0 +1,3 @@
+import type { Context, ESTree } from "@oxlint/plugins";
+/** Type binders in scope at a node, including mapped and inferred parameters. */
+export declare const lexicalTypeParameterNames: (node: ESTree.Node, context: Context) => readonly string[];

package/dist/anti-slop/shared/lexical-type-parameters.js

@@ -0,0 +1,25 @@
+import { Array } from "effect";
+import { childNodes } from "../../syntax.js";
+const inferNames = (context, node) => [
+    ...(node.type === "TSInferType" ? [node.typeParameter.name.name] : []),
+    ...Array.flatMap(childNodes(context, node), (child) => inferNames(context, child)),
+];
+const namesAt = (context, current, descendant) => {
+    if (current === null || current.type === "Program")
+        return [];
+    return [
+        ...("typeParameters" in current
+            ? Array.map(current.typeParameters?.params ?? [], (parameter) => parameter.name.name)
+            : []),
+        ...(current.type === "TSMappedType" &&
+            (descendant === current.nameType || descendant === current.typeAnnotation)
+            ? [current.key.name]
+            : []),
+        ...(current.type === "TSConditionalType" && descendant === current.trueType
+            ? inferNames(context, current.extendsType)
+            : []),
+        ...namesAt(context, current.parent, current),
+    ];
+};
+/** Type binders in scope at a node, including mapped and inferred parameters. */
+export const lexicalTypeParameterNames = (node, context) => namesAt(context, node, node);

package/dist/anti-slop/shared/reflect-method.d.ts

@@ -0,0 +1,3 @@
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+/** Reports whether a call target names one method on the global Reflect object. */
+export declare function isGlobalReflectMethodCall(sourceCode: SourceCode, callee: ESTree.Expression, methodName: string): boolean;

package/dist/anti-slop/shared/reflect-method.js

@@ -0,0 +1,24 @@
+import { Option } from "effect";
+import { variableInScope } from "../../syntax.js";
+function resolveVariable(sourceCode, identifier) {
+    return Option.getOrNull(variableInScope(sourceCode.getScope(identifier), identifier.name));
+}
+function isGlobalReflect(sourceCode, expression) {
+    if (expression.type !== "Identifier" || expression.name !== "Reflect")
+        return false;
+    if (sourceCode.isGlobalReference(expression))
+        return true;
+    const variable = resolveVariable(sourceCode, expression);
+    return variable === null || variable.defs.length === 0;
+}
+/** Reports whether a call target names one method on the global Reflect object. */
+export function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
+    if (!("property" in callee) || !("object" in callee) || !("computed" in callee))
+        return false;
+    if (!isGlobalReflect(sourceCode, callee.object))
+        return false;
+    const property = callee.property;
+    return callee.computed
+        ? property.type === "Literal" && property.value === methodName
+        : property.type === "Identifier" && property.name === methodName;
+}

package/dist/bun.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "no-ambient-host-api": import("@oxlint/plugins").Rule;
+    };
+};
+export default _default;

package/dist/bun.js

@@ -0,0 +1,30 @@
+import { defineRule } from "@oxlint/plugins";
+import { Array, Option } from "effect";
+import { propertyName } from "./syntax.js";
+const ambientMethods = ["argv", "env", "file", "spawn", "spawnSync", "write"];
+const noAmbientHostApi = defineRule({
+    create(context) {
+        return {
+            MemberExpression(node) {
+                if (node.object?.type === "Identifier" &&
+                    node.object.name === "Bun" &&
+                    Option.exists(propertyName(node.property), (name) => Array.contains(ambientMethods, name))) {
+                    context.report({ messageId: "noAmbientHostApi", node });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Disallow direct Bun host APIs in Effect-owned TypeScript." },
+        messages: {
+            noAmbientHostApi: "Use decoded input and Effect platform services instead of direct Bun environment, file or process APIs.",
+        },
+        type: "problem",
+    },
+});
+export default {
+    meta: { name: "bun" },
+    rules: {
+        "no-ambient-host-api": noAmbientHostApi,
+    },
+};

package/dist/effect.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "no-ambient-process": import("@oxlint/plugins").Rule;
+        "no-async-await-promise": import("@oxlint/plugins").Rule;
+        "no-console": import("@oxlint/plugins").Rule;
+        "no-instanceof": import("@oxlint/plugins").Rule;
+        "no-manual-tag": import("@oxlint/plugins").Rule;
+        "no-raw-fetch": import("@oxlint/plugins").Rule;
+        "no-runtime-execution-outside-main": import("@oxlint/plugins").Rule;
+        "no-unchecked-json": import("@oxlint/plugins").Rule;
+        "require-service-operation-instrumentation": import("@oxlint/plugins").Rule;
+    };
+};
+export default _default;