@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/injection-container.js

@@ -10,7 +10,7 @@ import { isClassDeclaration, isClassExpression, isConstructorDeclaration, isGetA
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, callsOf, classesPassed, decoratorsOf, spelledDecorator } from "./calls.js";
 import { classMembers } from "./class-members.js";
-import { entriesAt, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { entriesAt, namesADeclaration, resolveEntries, spelledEntry, } from "./roots/configured-declarations.js";
 import { isParameterProperty, nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 /** Whether one member declaration is a parameter property, or a property or accessor carrying a decorator. */
@@ -24,7 +24,7 @@ function isInjected(node) {
 /** The classes of the target a call whose callee an entry names passes, with that call's entry. */
 function registrations(input) {
     const { project, held } = input;
-    const resolved = resolveEntries(project, held, input.ts.injectionRegistrations);
+    const resolved = resolveEntries(project, held, input.ts.injection_registrations);
     if (!resolved.some(namesADeclaration)) {
         return [];
     }

package/dist/src/interface-satisfaction.js

@@ -9,7 +9,7 @@
 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";
+import { emptyImplementation } from "./findings/implementations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";

package/dist/src/intra-function-parts.js

@@ -4,6 +4,7 @@
  * call sites that use or discard it, each statement control flow cannot reach, each
  * write to a local that no read reaches, and each case an earlier case covers.
  */
+import { CODE } from "./contract/contract.generated.js";
 import { isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isConstructorDeclaration, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isForInStatement, isForOfStatement, isFunctionLikeDeclaration, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAssignment, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isSourceFile, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableDeclarationList, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { SignatureKind } from "@typescript/native/sync";
 import { exportsLocally, implicitReads, importBindings, } from "./import-bindings.js";
@@ -13,12 +14,7 @@ import { importRef } from "./ref.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 import { signatureOf } from "./signatures.js";
 import { spellsNoBinding } from "./spelled-names.js";
-/** The codes of the parts this module reads. */
-export const UNUSED_PARAMETER = "DS1801";
-export const UNUSED_RESULT = "DS1803";
-const UNREACHABLE_STATEMENT = "DS1805";
-const DEAD_STORE = "DS1807";
-const UNREACHABLE_CASE = "DS1809";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The result types that carry no value, as the checker spells them. */
 const NO_VALUE = new Set([
     "void",
@@ -34,17 +30,13 @@ function spanOf(file, root, node) {
     const endLine = file.getLineAndCharacterOfPosition(node.end).line + 1;
     return { ...start, endLine };
 }
-/** The parenthesized expression's content, through every pair of parentheses. */
-function unwrapped(node) {
-    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
 /** The node the parentheses around one expression sit in. */
 function outerParent(node) {
     return isParenthesizedExpression(node.parent) ? outerParent(node.parent) : node.parent;
 }
 /** The name a call is made through: the identifier, or the member a property access names. */
 function calleeName(call) {
-    const callee = unwrapped(call.expression);
+    const callee = parenthesesRemoved(call.expression);
     if (isIdentifier(callee)) {
         return callee;
     }
@@ -99,7 +91,7 @@ function unreachableExempt(statement) {
 }
 /** The value a case expression is a literal of, as a key two equal literals share, or none. */
 function caseKey(expression) {
-    const node = unwrapped(expression);
+    const node = parenthesesRemoved(expression);
     if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
         return `s:${node.text}`;
     }
@@ -210,7 +202,7 @@ function extendedNames(files) {
                     named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
                 }
                 else {
-                    const expression = unwrapped(type.expression);
+                    const expression = parenthesesRemoved(type.expression);
                     named = isPropertyAccessExpression(expression) ? expression.name : expression;
                 }
                 if (isIdentifier(named)) {
@@ -254,7 +246,7 @@ function decoratorFixes(constructor) {
 }
 /** The name an expression spells a class by: an identifier, or the member a property access names. */
 function spelledName(expression) {
-    const node = unwrapped(expression);
+    const node = parenthesesRemoved(expression);
     if (isIdentifier(node)) {
         return node;
     }
@@ -447,8 +439,8 @@ export function projectParts(project, held, references, targetRoot) {
             if ((isImportClause(node) || isNamespaceImport(node)) && node.name !== undefined) {
                 specifiers.add(position(node.name));
             }
-            if (isExportAssignment(node) && isIdentifier(unwrapped(node.expression))) {
-                specifiers.add(position(unwrapped(node.expression)));
+            if (isExportAssignment(node) && isIdentifier(parenthesesRemoved(node.expression))) {
+                specifiers.add(position(parenthesesRemoved(node.expression)));
             }
             if (isSwitchStatement(node)) {
                 const holder = holderOf(node);
@@ -572,7 +564,7 @@ export function projectParts(project, held, references, targetRoot) {
         }
         walk.catches.forEach(({ name, holder }, at) => {
             parts.push({
-                code: DEAD_STORE,
+                code: CODE.deadStore,
                 declaration: holder,
                 kind: "store",
                 name: name.text,
@@ -584,7 +576,7 @@ export function projectParts(project, held, references, targetRoot) {
         for (const { names, uses, holder } of loopVariables) {
             for (const name of names) {
                 parts.push({
-                    code: DEAD_STORE,
+                    code: CODE.deadStore,
                     declaration: holder,
                     kind: "store",
                     name: name.text,
@@ -602,7 +594,7 @@ export function projectParts(project, held, references, targetRoot) {
         });
         for (const { statement, holder } of walk.unreachable) {
             parts.push({
-                code: UNREACHABLE_STATEMENT,
+                code: CODE.unreachableStatement,
                 declaration: holder,
                 kind: "statement",
                 name: "statement",
@@ -613,7 +605,7 @@ export function projectParts(project, held, references, targetRoot) {
         }
         for (const { clause, text, holder } of walk.cases) {
             parts.push({
-                code: UNREACHABLE_CASE,
+                code: CODE.unreachableCase,
                 declaration: holder,
                 kind: "case",
                 name: text,
@@ -772,10 +764,9 @@ function calleeSteers(project, signature, at) {
 }
 /**
  * The parts with each name of `contextual` judged where the compiler gives its function a
- * contextual type: the code handing the argument may act on what an object pattern reads,
- * so each such name is read, and an annotated parameter is marked with whether the call's
- * inference may read its annotation. A question the checker leaves unanswered keeps the
- * name read.
+ * contextual type: a name an object pattern binds is marked as one, and an annotated
+ * parameter with whether the call's inference may read its annotation. A question the
+ * checker leaves unanswered keeps the name read.
  */
 function withContextualRead(project, parts, contextual) {
     if (contextual.length === 0) {
@@ -791,15 +782,17 @@ function withContextualRead(project, parts, contextual) {
             continue;
         }
         const place = one.part.parameter;
-        judged.set(one.part, one.pattern || answer === UNANSWERED || place === undefined
+        judged.set(one.part, answer === UNANSWERED || place === undefined
             ? { ...one.part, used: true }
-            : {
-                ...one.part,
-                parameter: {
-                    ...place,
-                    annotated: calleeSteers(project, one.signature, one.at) ? "steers" : "free",
-                },
-            });
+            : one.pattern
+                ? { ...one.part, parameter: { ...place, contextualPattern: true } }
+                : {
+                    ...one.part,
+                    parameter: {
+                        ...place,
+                        annotated: calleeSteers(project, one.signature, one.at) ? "steers" : "free",
+                    },
+                });
     }
     return parts.map((part) => judged.get(part) ?? part);
 }
@@ -825,7 +818,7 @@ function parameterParts(file, root, declaration, signature, reader, ids, place)
             return;
         }
         const part = {
-            code: UNUSED_PARAMETER,
+            code: CODE.unusedParameter,
             declaration,
             kind: "parameter",
             name: name.text,
@@ -884,15 +877,28 @@ function functionOf(block) {
     }
 }
 /**
- * The locals one block declares with `let`, `const` or `var`, each with the names of the
- * block that spell it. A `var` of a nested block is one where no nested function of its
- * function names it, since the function scope holds it past the block's end.
+ * The locals one block declares with `let`, `const`, `var` or a function declaration
+ * inside a function, each with the names of the block that spell it. A `var` of a nested
+ * block is one where no nested function of its function names it, since the function scope
+ * holds it past the block's end.
  */
 function localsOf(block) {
     const declared = [];
     const scope = functionOf(block);
     const outlives = scope?.body !== block;
     block.statements.forEach((statement, at) => {
+        if (isFunctionDeclaration(statement)) {
+            if (scope !== undefined && statement.name !== undefined && statement.body !== undefined) {
+                declared.push({
+                    name: statement.name,
+                    statement: at,
+                    initialized: true,
+                    outlives: false,
+                    hoisted: true,
+                });
+            }
+            return;
+        }
         if (!isVariableStatement(statement)) {
             return;
         }
@@ -902,6 +908,11 @@ function localsOf(block) {
             return;
         }
         for (const declaration of list.declarations) {
+            // A write to a local typed `never` is the compiler's exhaustiveness check, which
+            // fails to compile once a case goes unhandled.
+            if (declaration.type?.kind === SyntaxKind.NeverKeyword) {
+                continue;
+            }
             for (const name of boundNames(declaration.name)) {
                 if (!blockScoped &&
                     outlives &&
@@ -913,6 +924,7 @@ function localsOf(block) {
                     statement: at,
                     initialized: declaration.initializer !== undefined,
                     outlives: !blockScoped && outlives,
+                    hoisted: false,
                 });
             }
         }
@@ -931,7 +943,7 @@ function isPlainWrite(use) {
     const parent = outerParent(use);
     return (isBinaryExpression(parent) &&
         parent.operatorToken.kind === SyntaxKind.EqualsToken &&
-        unwrapped(parent.left) === use);
+        parenthesesRemoved(parent.left) === use);
 }
 /**
  * The writes to the locals of one block that no read reaches. A write is a declaration's
@@ -944,7 +956,7 @@ function isPlainWrite(use) {
 function deadStores(file, root, block, holder, locals, ids) {
     const found = [];
     const deadAt = (local, target) => ({
-        code: DEAD_STORE,
+        code: CODE.deadStore,
         declaration: holder,
         kind: "store",
         name: local.name.text,
@@ -953,12 +965,20 @@ function deadStores(file, root, block, holder, locals, ids) {
         used: false,
     });
     for (const local of locals) {
-        const uses = local.uses.filter((use) => readsBinding(use, local.name, ids));
+        const own = local.hoisted ? block.statements[local.statement] : undefined;
+        // A function's reads of itself keep it no more than its absence would.
+        const uses = local.uses.filter((use) => readsBinding(use, local.name, ids) && (own === undefined || !within(use, own)));
         if (!local.outlives && uses.every(isPlainWrite)) {
-            const targets = [...(local.initialized ? [local.name] : []), ...uses];
+            // A declaration with no initializer writes `undefined`, the one store left to name.
+            const writes = [...(local.initialized ? [local.name] : []), ...uses];
+            const targets = writes.length === 0 ? [local.name] : writes;
             found.push(...targets.map((target) => deadAt(local, target)));
             continue;
         }
+        // A read anywhere in the block reads a function declaration, which is written first.
+        if (local.hoisted) {
+            continue;
+        }
         if (uses.some((use) => inNestedFunction(use, block))) {
             continue;
         }
@@ -969,12 +989,12 @@ function deadStores(file, root, block, holder, locals, ids) {
             if (!isExpressionStatement(statement)) {
                 return undefined;
             }
-            const expression = unwrapped(statement.expression);
+            const expression = parenthesesRemoved(statement.expression);
             if (!isBinaryExpression(expression) ||
                 expression.operatorToken.kind !== SyntaxKind.EqualsToken) {
                 return undefined;
             }
-            const target = unwrapped(expression.left);
+            const target = parenthesesRemoved(expression.left);
             return isIdentifier(target) && uses.includes(target)
                 ? { target, value: expression.right }
                 : undefined;
@@ -1052,7 +1072,7 @@ function resultParts(project, root, sites, references, calls) {
         const valued = project.queries.nonNullable(result);
         const members = isAnswered(valued) ? project.queries.propertiesOf(valued) : UNANSWERED;
         found.push({
-            code: UNUSED_RESULT,
+            code: CODE.unusedResult,
             declaration: id,
             kind: "result",
             name: "result",