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

package/src/intra-function-parts.ts

@@ -5,6 +5,7 @@
  * write to a local that no read reaches, and each case an earlier case covers.
  */
 
+import { CODE } from "./contract/contract.generated.ts";
 import {
   isArrowFunction,
   isAwaitExpression,
@@ -95,6 +96,7 @@ import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 import { signatureOf, type SignatureNode } from "./signatures.ts";
 import { spellsNoBinding } from "./spelled-names.ts";
+import { parenthesesRemoved } from "./unwrap.ts";
 
 /** The subject kind of each part this module reads. */
 type PartKind = "parameter" | "result" | "statement" | "store" | "case";
@@ -137,6 +139,12 @@ interface ParameterPlace {
    * so the annotation may steer the call's inference.
    */
   readonly annotated?: "steers" | "free";
+  /**
+   * Whether the name is one an object binding pattern of a parameter binds, and the
+   * compiler gives its function a contextual type: the code handing the argument may act on
+   * the pattern's read of the property, which the program does not show.
+   */
+  readonly contextualPattern?: true;
   /** Whether the compiler checks the parameter's file, so its unused-parameter rule may report it. */
   readonly checked: boolean;
 }
@@ -173,13 +181,6 @@ export interface ProjectParts {
   readonly constructions: ReadonlySet<string>;
 }
 
-/** 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";
-
 /** The result types that carry no value, as the checker spells them. */
 const NO_VALUE: ReadonlySet<string> = new Set([
   "void",
@@ -197,11 +198,6 @@ function spanOf(file: SourceFile, root: string, node: Node): FindingPosition {
   return { ...start, endLine };
 }
 
-/** The parenthesized expression's content, through every pair of parentheses. */
-function unwrapped(node: Node): Node {
-  return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
-
 /** The node the parentheses around one expression sit in. */
 function outerParent(node: Node): Node {
   return isParenthesizedExpression(node.parent) ? outerParent(node.parent) : node.parent;
@@ -209,7 +205,7 @@ function outerParent(node: Node): Node {
 
 /** The name a call is made through: the identifier, or the member a property access names. */
 function calleeName(call: CallExpression): Identifier | undefined {
-  const callee = unwrapped(call.expression);
+  const callee = parenthesesRemoved(call.expression);
   if (isIdentifier(callee)) {
     return callee;
   }
@@ -276,7 +272,7 @@ function unreachableExempt(statement: Statement): boolean {
 
 /** The value a case expression is a literal of, as a key two equal literals share, or none. */
 function caseKey(expression: Node): string | undefined {
-  const node = unwrapped(expression);
+  const node = parenthesesRemoved(expression);
   if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
     return `s:${node.text}`;
   }
@@ -402,7 +398,7 @@ function extendedNames(files: readonly SourceFile[]): ReadonlySet<string> {
         if (isTypeReferenceNode(type)) {
           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)) {
@@ -455,7 +451,7 @@ function decoratorFixes(constructor: ConstructorDeclaration): boolean {
 
 /** The name an expression spells a class by: an identifier, or the member a property access names. */
 function spelledName(expression: Node): Identifier | undefined {
-  const node = unwrapped(expression);
+  const node = parenthesesRemoved(expression);
   if (isIdentifier(node)) {
     return node;
   }
@@ -724,8 +720,8 @@ export function projectParts<Brand>(
       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);
@@ -863,7 +859,7 @@ export function projectParts<Brand>(
     }
     walk.catches.forEach(({ name, holder }, at) => {
       parts.push({
-        code: DEAD_STORE,
+        code: CODE.deadStore,
         declaration: holder,
         kind: "store",
         name: name.text,
@@ -875,7 +871,7 @@ export function projectParts<Brand>(
     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,
@@ -893,7 +889,7 @@ export function projectParts<Brand>(
     });
     for (const { statement, holder } of walk.unreachable) {
       parts.push({
-        code: UNREACHABLE_STATEMENT,
+        code: CODE.unreachableStatement,
         declaration: holder,
         kind: "statement",
         name: "statement",
@@ -904,7 +900,7 @@ export function projectParts<Brand>(
     }
     for (const { clause, text, holder } of walk.cases) {
       parts.push({
-        code: UNREACHABLE_CASE,
+        code: CODE.unreachableCase,
         declaration: holder,
         kind: "case",
         name: text,
@@ -1093,10 +1089,9 @@ function calleeSteers<Brand>(
 
 /**
  * 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<Brand>(
   project: ProjectView<Brand>,
@@ -1118,15 +1113,17 @@ function withContextualRead<Brand>(
     const place = one.part.parameter;
     judged.set(
       one.part,
-      one.pattern || answer === UNANSWERED || place === undefined
+      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);
@@ -1169,7 +1166,7 @@ function parameterParts(
       return;
     }
     const part: PartFact = {
-      code: UNUSED_PARAMETER,
+      code: CODE.unusedParameter,
       declaration,
       kind: "parameter",
       name: name.text,
@@ -1205,6 +1202,8 @@ interface Local {
   readonly uses: readonly Identifier[];
   /** A `var` of a nested block, whose function scope outlives the block's end. */
   readonly outlives: boolean;
+  /** A function declaration, written at the start of the block whatever its place. */
+  readonly hoisted: boolean;
 }
 
 /**
@@ -1244,9 +1243,10 @@ function functionOf(block: Block): FunctionLikeDeclaration | undefined {
 }
 
 /**
- * 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: Block): readonly Local[] {
   const declared: {
@@ -1254,10 +1254,23 @@ function localsOf(block: Block): readonly Local[] {
     statement: number;
     initialized: boolean;
     outlives: boolean;
+    hoisted: boolean;
   }[] = [];
   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;
     }
@@ -1267,6 +1280,11 @@ function localsOf(block: Block): readonly Local[] {
       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 &&
@@ -1282,6 +1300,7 @@ function localsOf(block: Block): readonly Local[] {
           statement: at,
           initialized: declaration.initializer !== undefined,
           outlives: !blockScoped && outlives,
+          hoisted: false,
         });
       }
     }
@@ -1302,7 +1321,7 @@ function isPlainWrite(use: Identifier): boolean {
   return (
     isBinaryExpression(parent) &&
     parent.operatorToken.kind === SyntaxKind.EqualsToken &&
-    unwrapped(parent.left) === use
+    parenthesesRemoved(parent.left) === use
   );
 }
 
@@ -1324,7 +1343,7 @@ function deadStores(
 ): PartFact[] {
   const found: PartFact[] = [];
   const deadAt = (local: Local, target: Identifier): PartFact => ({
-    code: DEAD_STORE,
+    code: CODE.deadStore,
     declaration: holder,
     kind: "store",
     name: local.name.text,
@@ -1333,12 +1352,22 @@ function deadStores(
     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;
     }
@@ -1349,14 +1378,14 @@ function deadStores(
       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;
@@ -1443,7 +1472,7 @@ function resultParts<Brand>(
     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",