@jameswyse/oxc-config 0.2.0 → 0.3.0

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) {

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

@@ -1,4 +1,4 @@
-import { createTypeAliasEnvironment, hasVisibleTypeBinding, visibleTypeAlias, } from "./type-alias-resolution.js";
+import { aliasSubstitutions, createTypeAliasEnvironment, hasVisibleTypeBinding, visibleTypeAlias, } from "./type-alias-resolution.js";
 const BUILT_INS = new Set([
     "Record",
     "Readonly",
@@ -35,6 +35,9 @@ function typeReferenceName(type) {
 function isBuiltIn(name, use, environment) {
     return BUILT_INS.has(name) && !hasVisibleTypeBinding(name, use, environment.typeAliases);
 }
+function mappedKey(type) {
+    return type.nameType ?? type.constraint;
+}
 function unwrapTransparentType(type) {
     let current = type;
     while (current.type === "TSParenthesizedType" ||
@@ -43,12 +46,6 @@ function unwrapTransparentType(type) {
     }
     return current;
 }
-function isUnappliedReferenceTo(type, name) {
-    const unwrapped = unwrapTransparentType(type);
-    return (unwrapped.type === "TSTypeReference" &&
-        typeReferenceName(unwrapped) === name &&
-        (unwrapped.typeArguments === null || unwrapped.typeArguments.params.length === 0));
-}
 function isNeverType(type) {
     return unwrapTransparentType(type).type === "TSNeverKeyword";
 }
@@ -70,36 +67,6 @@ function isEffectivelyEmptyInterface(declarations) {
         type.extends.length === 0 &&
         (type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember)));
 }
-function resolvedSubstitutionArgument(type, base, resolving = new Set()) {
-    const unwrapped = unwrapTransparentType(type);
-    if (unwrapped.type !== "TSTypeReference") {
-        return type;
-    }
-    const name = typeReferenceName(unwrapped);
-    if (name === null || resolving.has(name)) {
-        return type;
-    }
-    const substitution = base.get(name);
-    if (substitution === void 0) {
-        return type;
-    }
-    const nextResolving = new Set(resolving);
-    nextResolving.add(name);
-    return resolvedSubstitutionArgument(substitution, base, nextResolving);
-}
-function aliasSubstitution(alias, type, base) {
-    const parameters = alias.typeParameters?.params ?? [];
-    const arguments_ = type.typeArguments?.params ?? [];
-    const next = new Map(base);
-    for (const [index, parameter] of parameters.entries()) {
-        const argument = arguments_[index] ?? parameter.default;
-        if (argument === null) {
-            return null;
-        }
-        next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
-    }
-    return next;
-}
 function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
     const unwrapped = unwrapTransparentType(type);
     if (unwrapped.type === "TSUnknownKeyword") {
@@ -144,9 +111,7 @@ function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
     }
     const substitution = substitutions.get(name);
     if (substitution !== void 0) {
-        return isUnappliedReferenceTo(substitution, name)
-            ? null
-            : unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+        return unsafeDirectValue(substitution.type, environment, substitution.substitutions, resolvingAliases);
     }
     const interfaceDeclarations = environment.interfaces.get(name);
     if (interfaceDeclarations !== void 0) {
@@ -156,7 +121,7 @@ function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
     if (alias === null || resolvingAliases.has(name)) {
         return null;
     }
-    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    const nextSubstitutions = aliasSubstitutions(alias, unwrapped, substitutions);
     if (nextSubstitutions === null) {
         return null;
     }
@@ -164,6 +129,50 @@ function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
     nextResolving.add(name);
     return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
 }
+function isBroadMappedKey(type, environment, substitutions, visitedAliases = new Set()) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSStringKeyword" ||
+        unwrapped.type === "TSNumberKeyword" ||
+        unwrapped.type === "TSSymbolKeyword") {
+        return true;
+    }
+    if (unwrapped.type === "TSUnionType") {
+        return unwrapped.types.some((member) => isBroadMappedKey(member, environment, substitutions, visitedAliases));
+    }
+    if (unwrapped.type !== "TSTypeReference") {
+        return false;
+    }
+    const name = typeReferenceName(unwrapped);
+    if (name === null) {
+        return false;
+    }
+    const substitution = substitutions.get(name);
+    if (substitution !== void 0) {
+        return isBroadMappedKey(substitution.type, environment, substitution.substitutions, visitedAliases);
+    }
+    if (name === "PropertyKey" && isBuiltIn(name, unwrapped, environment)) {
+        return true;
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null ||
+        (alias.typeParameters?.params.length ?? 0) > 0 ||
+        visitedAliases.has(name)) {
+        return false;
+    }
+    const nextVisited = new Set(visitedAliases);
+    nextVisited.add(name);
+    return isBroadMappedKey(alias.typeAnnotation, environment, substitutions, nextVisited);
+}
+function keptDictionarySource(type, environment, substitutions) {
+    const [source, keys] = type.typeArguments?.params ?? [];
+    if (source === void 0) {
+        return null;
+    }
+    return typeReferenceName(type) === "Omit" ||
+        (keys !== void 0 && isBroadMappedKey(keys, environment, substitutions))
+        ? source
+        : null;
+}
 function dictionaryValueTypes(type, environment, substitutions, resolvingAliases) {
     const unwrapped = unwrapTransparentType(type);
     if (unwrapped.type === "TSTypeLiteral") {
@@ -185,9 +194,7 @@ function dictionaryValueTypes(type, environment, substitutions, resolvingAliases
     }
     const substitution = substitutions.get(name);
     if (substitution !== void 0) {
-        return isUnappliedReferenceTo(substitution, name)
-            ? []
-            : dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
+        return dictionaryValueTypes(substitution.type, environment, substitution.substitutions, resolvingAliases);
     }
     if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
         const wrapped = unwrapped.typeArguments?.params[0];
@@ -200,8 +207,8 @@ function dictionaryValueTypes(type, environment, substitutions, resolvingAliases
         return value === null ? [] : [{ type: value, substitutions }];
     }
     if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, environment)) {
-        const source = unwrapped.typeArguments?.params[0];
-        return source === void 0
+        const source = keptDictionarySource(unwrapped, environment, substitutions);
+        return source === null
             ? []
             : dictionaryValueTypes(source, environment, substitutions, resolvingAliases);
     }
@@ -209,7 +216,7 @@ function dictionaryValueTypes(type, environment, substitutions, resolvingAliases
     if (alias === null || resolvingAliases.has(name)) {
         return [];
     }
-    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    const nextSubstitutions = aliasSubstitutions(alias, unwrapped, substitutions);
     if (nextSubstitutions === null) {
         return [];
     }
@@ -230,40 +237,6 @@ function classifyUnsafeDictionary(type, environment) {
     }
     return null;
 }
-function isBroadMappedKey(type, environment, substitutions, visitedAliases = new Set()) {
-    const unwrapped = unwrapTransparentType(type);
-    if (unwrapped.type === "TSStringKeyword" ||
-        unwrapped.type === "TSNumberKeyword" ||
-        unwrapped.type === "TSSymbolKeyword") {
-        return true;
-    }
-    if (unwrapped.type === "TSUnionType") {
-        return unwrapped.types.some((member) => isBroadMappedKey(member, environment, substitutions, visitedAliases));
-    }
-    if (unwrapped.type !== "TSTypeReference") {
-        return false;
-    }
-    const name = typeReferenceName(unwrapped);
-    if (name === null) {
-        return false;
-    }
-    const substitution = substitutions.get(name);
-    if (substitution !== void 0 && !isUnappliedReferenceTo(substitution, name)) {
-        return isBroadMappedKey(substitution, environment, substitutions, visitedAliases);
-    }
-    if (name === "PropertyKey" && isBuiltIn(name, unwrapped, environment)) {
-        return true;
-    }
-    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
-    if (alias === null ||
-        (alias.typeParameters?.params.length ?? 0) > 0 ||
-        visitedAliases.has(name)) {
-        return false;
-    }
-    const nextVisited = new Set(visitedAliases);
-    nextVisited.add(name);
-    return isBroadMappedKey(alias.typeAnnotation, environment, substitutions, nextVisited);
-}
 function hasBroadRecordKey(type, environment, substitutions) {
     const key = type.typeArguments?.params[0];
     return key === void 0 || isBroadMappedKey(key, environment, substitutions);
@@ -282,7 +255,7 @@ function classifyAliasBroadTarget(type, environment, substitutions, resolvingAli
             : null;
     }
     if (unwrapped.type === "TSMappedType") {
-        return isBroadMappedKey(unwrapped.constraint, environment, substitutions)
+        return isBroadMappedKey(mappedKey(unwrapped), environment, substitutions)
             ? { kind: "open dictionary" }
             : null;
     }
@@ -295,9 +268,7 @@ function classifyAliasBroadTarget(type, environment, substitutions, resolvingAli
     }
     const substitution = substitutions.get(name);
     if (substitution !== void 0) {
-        return isUnappliedReferenceTo(substitution, name)
-            ? null
-            : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+        return classifyAliasBroadTarget(substitution.type, environment, substitution.substitutions, resolvingAliases);
     }
     if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
         const wrapped = unwrapped.typeArguments?.params[0];
@@ -310,11 +281,18 @@ function classifyAliasBroadTarget(type, environment, substitutions, resolvingAli
             ? { kind: "open dictionary" }
             : null;
     }
+    if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, environment)) {
+        const source = keptDictionarySource(unwrapped, environment, substitutions);
+        const target = source === null
+            ? null
+            : classifyAliasBroadTarget(source, environment, substitutions, resolvingAliases);
+        return target?.kind === "open dictionary" ? target : null;
+    }
     const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
     if (alias === null || resolvingAliases.has(name)) {
         return null;
     }
-    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    const nextSubstitutions = aliasSubstitutions(alias, unwrapped, substitutions);
     if (nextSubstitutions === null) {
         return null;
     }
@@ -338,7 +316,9 @@ function classifyWideningTarget(type, environment) {
                 : null;
     }
     if (unwrapped.type === "TSMappedType") {
-        return { kind: "open dictionary" };
+        return isBroadMappedKey(mappedKey(unwrapped), environment, new Map())
+            ? { kind: "open dictionary" }
+            : null;
     }
     if (unwrapped.type !== "TSTypeReference") {
         return null;
@@ -356,18 +336,21 @@ function classifyWideningTarget(type, environment) {
             ? { kind: "open dictionary" }
             : null;
     }
+    if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, environment)) {
+        return classifyAliasBroadTarget(unwrapped, environment, new Map(), new Set());
+    }
     const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
     if (alias === null) {
         return null;
     }
     if ((alias.typeParameters?.params.length ?? 0) > 0) {
-        const substitutions2 = aliasSubstitution(alias, unwrapped, new Map());
+        const substitutions2 = aliasSubstitutions(alias, unwrapped, new Map());
         const resolved2 = substitutions2 === null
             ? null
             : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions2, new Set([name]));
         return resolved2?.kind === "open dictionary" ? { kind: "generic container" } : null;
     }
-    const substitutions = aliasSubstitution(alias, unwrapped, new Map());
+    const substitutions = aliasSubstitutions(alias, unwrapped, new Map());
     if (substitutions === null) {
         return null;
     }

package/dist/vendor/anti-slop/shared/type-alias-resolution.d.ts

@@ -7,6 +7,11 @@ type DeclaredTypeBinding = {
 type TypeBinding = DeclaredTypeBinding & {
     readonly scope: ESTree.Node;
 };
+type Substitution = {
+    readonly type: ESTree.TSType;
+    readonly substitutions: Substitutions;
+};
+type Substitutions = ReadonlyMap<string, Substitution>;
 type TypeAliasEnvironment = {
     readonly aliases: readonly ESTree.TSTypeAliasDeclaration[];
     readonly bindingsByName: ReadonlyMap<string, readonly TypeBinding[]>;
@@ -16,6 +21,7 @@ type ResolvedTypeMatcher = (type: ESTree.TSType, matches: (child: ESTree.TSType)
 declare function createTypeAliasEnvironment(program: ESTree.Program, visitorKeys: VisitorKeys): TypeAliasEnvironment;
 declare function visibleTypeAlias(name: string, use: ESTree.Node, environment: TypeAliasEnvironment): ESTree.TSTypeAliasDeclaration | null;
 declare function hasVisibleTypeBinding(name: string, use: ESTree.Node, environment: TypeAliasEnvironment): boolean;
+declare function aliasSubstitutions(alias: ESTree.TSTypeAliasDeclaration, reference: ESTree.TSTypeReference, base: Substitutions): Substitutions | null;
 declare function resolvedTypeMatches(type: ESTree.TSType, environment: TypeAliasEnvironment, matcher: ResolvedTypeMatcher): boolean;
-export type { ResolvedTypeMatcher, TypeAliasEnvironment };
-export { createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias };
+export type { ResolvedTypeMatcher, Substitution, Substitutions, TypeAliasEnvironment };
+export { aliasSubstitutions, createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias, };

package/dist/vendor/anti-slop/shared/type-alias-resolution.js

@@ -105,7 +105,7 @@ function typeReferenceName(type) {
 function aliasSubstitutions(alias, reference, base) {
     const parameters = alias.typeParameters?.params ?? [];
     const arguments_ = reference.typeArguments?.params ?? [];
-    const next = new Map(base);
+    const next = new Map();
     for (const [index, parameter] of parameters.entries()) {
         const explicitArgument = arguments_[index];
         const argument = explicitArgument ?? parameter.default;
@@ -144,4 +144,4 @@ function resolvedTypeMatches(type, environment, matcher) {
     };
     return evaluate(type, new Map(), new Set());
 }
-export { createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias };
+export { aliasSubstitutions, createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias, };