@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.2

package/dist/src/indexed-access.js

@@ -4,7 +4,7 @@
  * that parameter, and a call of a method of a generic receiver fixes the receiver's by its
  * type arguments. The type query of a type-query alias is no reference.
  */
-import { isArrowFunction, isBindingElement, isCallExpression, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isFunctionTypeNode, isIdentifier, isIndexedAccessTypeNode, isInterfaceDeclaration, isLiteralTypeNode, isMappedTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isParenthesizedTypeNode, isPropertyAccessExpression, isPropertySignatureDeclaration, isStringLiteral, isTypeAliasDeclaration, isTypeOperatorNode, isTypeReferenceNode, isUnionTypeNode, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { isArrowFunction, isBindingElement, isCallExpression, isClassDeclaration, isClassExpression, isConstructorDeclaration, isConstructorTypeNode, isFunctionDeclaration, isFunctionExpression, isFunctionTypeNode, isIdentifier, isIndexedAccessTypeNode, isInterfaceDeclaration, isLiteralTypeNode, isMappedTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isParenthesizedTypeNode, isPropertyAccessExpression, isPropertyAssignment, isPropertySignatureDeclaration, isStringLiteral, isTypeAliasDeclaration, isTypeOperatorNode, isTypeReferenceNode, isUnionTypeNode, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SignatureKind, SymbolFlags, } from "@typescript/native/sync";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
@@ -17,12 +17,25 @@ function isGeneric(node) {
         isArrowFunction(node) ||
         isFunctionExpression(node) ||
         isFunctionTypeNode(node) ||
+        isConstructorTypeNode(node) ||
         isTypeAliasDeclaration(node) ||
         isInterfaceDeclaration(node) ||
         isClassDeclaration(node) ||
         isClassExpression(node)) &&
         node.typeParameters !== undefined);
 }
+/** Whether a function declares no type parameter and a parameter whose type holds `keyof`. */
+function takesKeyof(node) {
+    if (!(isFunctionDeclaration(node) ||
+        isMethodDeclaration(node) ||
+        isMethodSignatureDeclaration(node) ||
+        isArrowFunction(node) ||
+        isFunctionExpression(node)) ||
+        node.typeParameters !== undefined) {
+        return false;
+    }
+    return node.parameters.some((parameter) => parameter.type !== undefined && keyofOperands(parameter.type).length > 0);
+}
 /** Whether one generic is a receiver's: a class or an interface whose methods it parameterizes. */
 function isReceiver(node) {
     return isInterfaceDeclaration(node) || isClassDeclaration(node) || isClassExpression(node);
@@ -57,8 +70,8 @@ function unwrappedType(node) {
 function literalNames(index) {
     const node = unwrappedType(index);
     if (isUnionTypeNode(node)) {
-        const names = node.types.map(literalNames);
-        return names.every((one) => one !== undefined) ? names.flat() : undefined;
+        const names = node.types.flatMap((one) => literalNames(one) ?? []);
+        return names.length > 0 ? names : undefined;
     }
     if (!isLiteralTypeNode(node)) {
         return undefined;
@@ -69,7 +82,7 @@ function literalNames(index) {
     }
     return isNumericLiteral(literal) ? [String(Number(literal.text))] : undefined;
 }
-/** The name a literal type carries, a union's each, or none where a constituent is no literal. */
+/** The names the literal constituents of a type carry: a key the type names is one the access requires. */
 function literalTypeNames(type, parts) {
     const names = [];
     for (const part of parts(type)) {
@@ -79,9 +92,6 @@ function literalTypeNames(type, parts) {
         else if (part.isNumberLiteralType()) {
             names.push(String(part.value));
         }
-        else {
-            return undefined;
-        }
     }
     return names;
 }
@@ -140,16 +150,21 @@ function calledName(generic) {
     }
     const parent = generic.parent;
     return parent !== undefined &&
-        (isVariableDeclaration(parent) || isPropertySignatureDeclaration(parent)) &&
+        (isVariableDeclaration(parent) ||
+            isPropertySignatureDeclaration(parent) ||
+            isPropertyAssignment(parent)) &&
         isIdentifier(parent.name)
         ? parent.name.text
         : undefined;
 }
 /** The generic a declaration a symbol names is: the function a variable is initialized with included. */
 function genericOf(node) {
-    if (isGeneric(node) || isReceiverMember(node)) {
+    if (isGeneric(node) || isReceiverMember(node) || takesKeyof(node)) {
         return node;
     }
+    if (isConstructorDeclaration(node) && isGeneric(node.parent)) {
+        return node.parent;
+    }
     if (isPropertySignatureDeclaration(node)) {
         // The typings mark the annotation present; a signature written without one has none.
         const declared = node.type;
@@ -238,6 +253,8 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
     const carried = new Map();
     const names = new Set();
     const sites = [];
+    /** Accesses indexed by a type parameter whose constraint is no `keyof`: it requires each key it names. */
+    const constrained = [];
     /** Calls passing an argument, which a generic declared outside the own files may fix. */
     const argumentCalls = [];
     const carry = (generic, one) => {
@@ -263,14 +280,23 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             const own = held.declarations.get(nodeKey(file, node));
             const holder = own ?? from;
             const inside = isGeneric(node) ? [...enclosing, node] : enclosing;
-            if (isGeneric(node)) {
+            if (isGeneric(node) || takesKeyof(node)) {
                 carriedIn(node).forEach((one) => carry(node, one));
             }
             if (isIndexedAccessTypeNode(node) && !aliasTypes.has(node)) {
                 const literal = literalNames(node.indexType);
+                const parameter = literal === undefined ? namedParameter(node.indexType, inside) : undefined;
+                const constraint = parameter === undefined
+                    ? undefined
+                    : parameter.generic.typeParameters?.[parameter.index]?.constraint;
                 if (literal !== undefined) {
                     accesses.push({ file, from: holder, at: node, object: node.objectType, index: literal });
                 }
+                else if (constraint !== undefined &&
+                    keyofOperands(constraint).length === 0 &&
+                    namedParameter(node.objectType, inside) === undefined) {
+                    constrained.push({ file, from: holder, at: node, object: node.objectType, constraint });
+                }
             }
             if (isTypeReferenceNode(node) &&
                 node.typeArguments !== undefined &&
@@ -287,7 +313,7 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
                 if (name !== undefined) {
                     const site = { file, from: holder, node, name, enclosing: inside };
                     sites.push(site);
-                    if (isCallExpression(node) && node.arguments.length > 0) {
+                    if (argumentsOf(node).length > 0) {
                         argumentCalls.push(site);
                     }
                 }
@@ -300,6 +326,35 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             visit(child, fileId, []);
         });
     }
+    /** The literal keys one constraint names, through the type aliases it references. */
+    const requiredNames = (node, seen) => {
+        const type = unwrappedType(node);
+        if (isUnionTypeNode(type)) {
+            return type.types.flatMap((one) => requiredNames(one, seen));
+        }
+        if (!isTypeReferenceNode(type) || type.typeArguments !== undefined) {
+            return literalNames(type) ?? [];
+        }
+        const [symbol] = queries.symbolsAt([type.typeName]);
+        if (symbol === UNANSWERED || symbol === undefined) {
+            return [];
+        }
+        return symbol.declarations.flatMap((handle) => {
+            const declared = project.declarationAt(handle)?.node;
+            return declared !== undefined &&
+                isTypeAliasDeclaration(declared) &&
+                declared.typeParameters === undefined &&
+                !seen.has(declared)
+                ? requiredNames(declared.type, new Set([...seen, declared]))
+                : [];
+        });
+    };
+    for (const { constraint, ...access } of constrained) {
+        const index = requiredNames(constraint, new Set());
+        if (index.length > 0) {
+            accesses.push({ ...access, index });
+        }
+    }
     function partsOf(type) {
         const parts = queries.constituents(type);
         return parts === UNANSWERED ? [type] : parts;
@@ -322,11 +377,13 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
      * variable holding the callee is initialized with.
      */
     const receiverTypeOf = (callee) => {
+        let operand;
         if (isPropertyAccessExpression(callee)) {
             const type = queries.typeAt(callee.expression);
-            const args = type === UNANSWERED || type === undefined ? [] : queries.typeArguments(type);
-            if (type !== UNANSWERED && type !== undefined && args !== UNANSWERED && args.length > 0) {
-                return type;
+            operand = type === UNANSWERED ? undefined : type;
+            const args = operand === undefined ? [] : queries.typeArguments(operand);
+            if (operand !== undefined && args !== UNANSWERED && args.length > 0) {
+                return operand;
             }
         }
         const name = isPropertyAccessExpression(callee) ? callee.name : callee;
@@ -335,7 +392,7 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             ? named
             : queries.aliased(named);
         if (symbol === UNANSWERED || symbol === undefined) {
-            return undefined;
+            return operand;
         }
         for (const handle of symbol.declarations) {
             const node = project.declarationAt(handle)?.node;
@@ -355,7 +412,40 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
                 return type;
             }
         }
-        return undefined;
+        return operand;
+    };
+    /**
+     * The instantiation of `owner` a receiver's type is, or the first one among the base
+     * types it extends, breadth first: a subclass fixes its base's type parameters, and
+     * `this` stands for its class.
+     */
+    const instantiationOf = (type, owner) => {
+        const seen = new Set();
+        for (let queue = [type]; queue.length > 0;) {
+            const next = [];
+            for (const at of queue) {
+                if (seen.has(at.id)) {
+                    continue;
+                }
+                seen.add(at.id);
+                const target = at.isTypeReference() ? queries.targetOf(at) : at;
+                const symbol = target === UNANSWERED ? undefined : queries.symbolOfType(target);
+                const declares = symbol !== undefined &&
+                    symbol !== UNANSWERED &&
+                    symbol.declarations.some((handle) => project.declarationAt(handle)?.node === owner);
+                if (declares) {
+                    return at;
+                }
+                const constraint = at.isTypeParameter() ? queries.constraintOf(at) : undefined;
+                const bases = at.isTypeParameter() ? [] : queries.baseTypes(at);
+                next.push(...(bases === UNANSWERED ? [] : bases));
+                if (constraint !== undefined && constraint !== UNANSWERED) {
+                    next.push(constraint);
+                }
+            }
+            queue = next;
+        }
+        return type;
     };
     /** What one site fixes for one side of a carried access. */
     const fixedAt = (site, side, generic) => {
@@ -365,7 +455,9 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
         const { node } = site;
         if (side.kind === "receiver") {
             const callee = isCallExpression(node) ? node.expression : undefined;
-            const receiver = callee === undefined ? undefined : receiverTypeOf(callee);
+            const owner = receiverOf(generic);
+            const typed = callee === undefined ? undefined : receiverTypeOf(callee);
+            const receiver = typed === undefined || owner === undefined ? typed : instantiationOf(typed, owner);
             if (receiver === undefined) {
                 return undefined;
             }
@@ -389,7 +481,7 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
         if (isTypeReferenceNode(node)) {
             return undefined;
         }
-        const at = (generic.parameters ?? []).findIndex((parameter) => {
+        const at = parametersOf(generic).findIndex((parameter) => {
             const type = parameter.type === undefined ? undefined : unwrappedType(parameter.type);
             return (type !== undefined &&
                 isTypeReferenceNode(type) &&
@@ -482,9 +574,7 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
     // by its type parameters and its receiver's. Only a call passing an argument the compiler
     // types as a literal can fix an index, so only such a call's signature is resolved.
     const outside = argumentCalls.filter((site) => !resolvedGenerics.has(site));
-    const argumentNodes = argumentCalls.flatMap((site) => [
-        ...site.node.arguments,
-    ]);
+    const argumentNodes = argumentCalls.flatMap((site) => argumentsOf(site.node));
     const argumentTypes = queries.typesAt(argumentNodes);
     const literalArgument = new Set();
     argumentTypes.forEach((type, at) => {
@@ -492,13 +582,13 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
         if (node !== undefined &&
             type !== UNANSWERED &&
             type !== undefined &&
-            (literalTypeNames(type, partsOf)?.length ?? 0) > 0) {
+            literalTypeNames(type, partsOf).length > 0) {
             literalArgument.add(node);
         }
     });
     const own = project.ownPaths();
     for (const site of outside) {
-        if (!site.node.arguments.some((one) => literalArgument.has(one))) {
+        if (!argumentsOf(site.node).some((one) => literalArgument.has(one))) {
             continue;
         }
         const resolved = queries.resolvedSignature(site.node);
@@ -516,7 +606,7 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
         }
     }
     for (const site of argumentCalls) {
-        if (site.node.arguments.some((one) => literalArgument.has(one))) {
+        if (argumentsOf(site.node).some((one) => literalArgument.has(one))) {
             accesses.push(...instantiatedAccesses(site));
         }
     }
@@ -536,7 +626,7 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             generic === undefined) {
             return [];
         }
-        const count = site.node.arguments.length;
+        const count = argumentsOf(site.node).length;
         const parameters = [];
         for (let at = 0; at < count; at += 1) {
             const type = queries.parameterType(generic, at);
@@ -573,13 +663,13 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             }
             const names = access.index.isTypeParameter()
                 ? parameters.flatMap((parameter, at) => {
-                    if (parameter.id !== access.index.id) {
+                    if (!partsOf(parameter).some((part) => part.id === access.index.id)) {
                         return [];
                     }
                     const passed = queries.typeAtPosition(resolved, at);
-                    return passed === UNANSWERED ? [] : (literalTypeNames(passed, partsOf) ?? []);
+                    return passed === UNANSWERED ? [] : literalTypeNames(passed, partsOf);
                 })
-                : (literalTypeNames(access.index, partsOf) ?? []);
+                : literalTypeNames(access.index, partsOf);
             if (names.length > 0) {
                 found.push({
                     file: site.file,
@@ -643,6 +733,18 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
     }
     return found;
 }
+/** The arguments a call or a `new` expression passes, none for a type reference. */
+function argumentsOf(node) {
+    return isTypeReferenceNode(node) ? [] : (node.arguments ?? []);
+}
+/** The parameters a site's arguments bind: a class's are its constructor's. */
+function parametersOf(generic) {
+    if (isClassDeclaration(generic) || isClassExpression(generic)) {
+        const constructor = generic.members.find(isConstructorDeclaration);
+        return constructor?.parameters ?? [];
+    }
+    return generic.parameters ?? [];
+}
 /** What makes two carried accesses one: the kind and position of each side, or its written node. */
 function sideKey(one) {
     const key = (side) => side.kind === "written" ? ["written", side.node.pos, side.node.end] : [side.kind, side.index];

package/dist/src/interface-satisfaction.js

@@ -1,12 +1,12 @@
 /**
  * The interface-satisfaction class: a member is held back when a value of its class
- * reaches a position the checker types as an interface requiring that member, through an
- * `implements` entry, a typed initializer, an assignment, an argument, a return, an array
- * element, an object property or an `as` or `satisfies` operand. `this` is a value of its
- * class, and a position typed by a type parameter reaches its constraint. The contextual
- * lookup has no batch form, so it is asked only of a value typed as a target class.
+ * reaches a position typed as an interface, or an object type a type alias names, that
+ * requires the member: an `implements` entry, a typed initializer, an assignment, an
+ * argument, a return, an array element, an object property or an `as` or `satisfies`
+ * operand. `this` is a value of its class; a type parameter reaches its constraint. The
+ * contextual lookup has no batch form, so it is asked only of a value of a target class.
  */
-import { isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isSetAccessorDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/ast";
+import { isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isSetAccessorDeclaration, isTypeLiteralNode, ModifierFlags, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { emptyImplementation } from "./implementations.js";
@@ -14,6 +14,10 @@ import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";
 import { handedOn, valuesOf } from "./value-flow.js";
+/** Whether a type alias names one type: the client's type object carries the alias it was written through. */
+function aliased(type) {
+    return type.aliasSymbol !== undefined;
+}
 /** Whether one node declares a static member, whose `this` is the class itself. */
 function isStatic(node) {
     const flags = node.modifierFlags ?? 0;
@@ -146,19 +150,33 @@ export function interfaceSatisfaction(input) {
         return generic === undefined ? [] : [{ owner: generic, type: part }];
     });
     const interfaceNames = new Map();
-    /** The interface types one position's type is or holds, each with the interface's name. */
+    /**
+     * The interface types one position's type is or holds, each with the interface's name:
+     * an interface, or an object type literal a type alias names, directly or as a
+     * constituent of an intersection the alias names.
+     */
     const interfacesOf = (type) => partsOf(type).flatMap((part) => {
         if (part.isTypeParameter()) {
             const constraint = must(queries.constraintOf(part));
             return constraint === undefined ? [] : interfacesOf(constraint);
         }
-        if (!interfaceNames.has(part.id)) {
+        const named = aliased(part) ? part : aliased(type) ? type : undefined;
+        const key = `${String(part.id)}:${String(named?.id ?? "")}`;
+        if (!interfaceNames.has(key)) {
             const symbol = part.isObjectType() ? must(queries.symbolOfType(part)) : undefined;
-            interfaceNames.set(part.id, symbol !== undefined && (symbol.flags & SymbolFlags.Interface) !== 0
-                ? symbol.name
-                : undefined);
+            const flags = symbol?.flags ?? 0;
+            interfaceNames.set(key, (flags & SymbolFlags.Interface) !== 0
+                ? symbol?.name
+                : (flags & SymbolFlags.TypeLiteral) !== 0 &&
+                    named !== undefined &&
+                    symbol?.declarations.some((handle) => {
+                        const node = project.declarationAt(handle)?.node;
+                        return node !== undefined && isTypeLiteralNode(node);
+                    }) === true
+                    ? must(queries.typeToString(named))
+                    : undefined);
         }
-        const name = interfaceNames.get(part.id);
+        const name = interfaceNames.get(key);
         return name === undefined ? [] : [{ type: part, name }];
     });
     /**