@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.10

package/src/html-entries.ts

@@ -12,8 +12,10 @@ import {
 } from "@typescript/native/ast";
 import { resolveRelativeSpecifier, type ParseFile } from "./configuration-files.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { filesBelow } from "./fs/tree.ts";
+import { holdsManifest } from "./fs/manifest.ts";
 
 /** One file a script loads, and the value or specifier that named it. */
 interface HTMLEntry {
@@ -21,9 +23,6 @@ interface HTMLEntry {
   readonly source: string;
 }
 
-/** The directory no HTML file is read below. */
-const SKIPPED = "node_modules";
-
 /** A `<script` start tag, its attribute text captured. */
 const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
 
@@ -42,28 +41,6 @@ const CLASSIC_TYPES: ReadonlySet<string> = new Set(["text/javascript", "applicat
 /** The prefixes an inline script's specifier names a file of the target with. */
 const FILE_PREFIXES = ["/", "./", "../"] as const;
 
-/** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
-function htmlFiles(host: Host, dir: string): readonly string[] {
-  let entries;
-  try {
-    entries = host.readDirectory(dir);
-  } catch {
-    return [];
-  }
-  const found: string[] = [];
-  for (const entry of entries) {
-    const path = joinPath(dir, entry.name);
-    if (entry.directory) {
-      if (entry.name !== SKIPPED) {
-        found.push(...htmlFiles(host, path));
-      }
-    } else if (entry.name.endsWith(".html")) {
-      found.push(path);
-    }
-  }
-  return found.sort();
-}
-
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text: string): ReadonlyMap<string, string> {
   const found = new Map<string, string>();
@@ -127,12 +104,7 @@ function scriptValues(parse: ParseFile | undefined, path: string, text: string):
 
 /** The directory of the nearest `package.json` at or above `dir`, inside `root`, else `root`. */
 function manifestDirectory(host: Host, root: string, dir: string): string {
-  for (let at = dir; relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-    if (host.kindOf(joinPath(at, "package.json")) === "file") {
-      return at;
-    }
-  }
-  return root;
+  return ancestors(dir, root).find((at) => holdsManifest(host, at)) ?? root;
 }
 
 /**
@@ -150,7 +122,8 @@ export function htmlEntries(
 ): readonly HTMLEntry[] {
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const found: HTMLEntry[] = [];
-  for (const path of htmlFiles(host, root)) {
+  for (const below of filesBelow(host, root, (name) => name.endsWith(".html"))) {
+    const path = joinPath(root, below);
     let text: string;
     try {
       text = host.readFile(path);

package/src/in-operands.ts

@@ -13,6 +13,7 @@ import {
 } from "@typescript/native/ast";
 import type { ProjectView } from "./session.ts";
 import { sourceFilesOf } from "./source-files.ts";
+import { bytewise } from "./text/compare.ts";
 
 /**
  * The text of each string literal, or template literal with no substitution, written as
@@ -41,5 +42,5 @@ export function inOperandNames<Brand>(
       file.forEachChild(visit);
     }
   }
-  return [...found].sort();
+  return [...found].sort(bytewise);
 }

package/src/index.ts

@@ -19,4 +19,4 @@ export {
   type Fragment,
   type Module,
 } from "./ref.ts";
-export { CONTRACT_VERSION } from "./version.ts";
+export { CONTRACT_VERSION } from "./contract/contract.generated.ts";

package/src/injection-container.ts

@@ -53,7 +53,7 @@ function isInjected(node: Node): boolean {
 /** The classes of the target a call whose callee an entry names passes, with that call's entry. */
 function registrations<Brand>(input: DetectorInput<Brand>): readonly Registration[] {
   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/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",

package/src/inventory.ts

@@ -50,6 +50,7 @@ import {
 import { computedComponent, nameComponent, renderRef, type Component, type Module } from "./ref.ts";
 import { isAnswered, UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
+import { manifestAt } from "./fs/manifest.ts";
 
 /**
  * The symbol inventory of one project: every declaration the target's own files
@@ -233,8 +234,6 @@ interface ExportScope {
   readonly nameNode: Node;
 }
 
-const MANIFEST = "package.json";
-
 /** One manifest that names a package, and the directory below the root that holds it. */
 interface Named {
   readonly name: string;
@@ -255,24 +254,7 @@ export function packageScope(host: Host, root: string): (path: string) => Module
   const named = new Map<string, Named | undefined>();
 
   const manifestName = (dir: string): string | undefined => {
-    let text: string;
-    try {
-      text = host.readFile(joinPath(root, dir, MANIFEST));
-    } catch {
-      return undefined;
-    }
-    let value: unknown;
-    try {
-      value = JSON.parse(text);
-    } catch {
-      // A manifest this program cannot read names no package, which is the same
-      // answer as an absent one: the file is then scoped by the target root.
-      return undefined;
-    }
-    if (typeof value !== "object" || value === null) {
-      return undefined;
-    }
-    const name = (value as Record<string, unknown>)["name"];
+    const name = manifestAt(host, joinPath(root, dir))?.["name"];
     return typeof name === "string" && name !== "" ? name : undefined;
   };
 

package/src/javascript-file.ts

@@ -0,0 +1,37 @@
+export const JAVASCRIPT_FILE = /\.(?:js|jsx|mjs|cjs)$/u;
+
+/** A minified file by its name; any other is one by its size and its mean line length. */
+const MINIFIED_NAME = /\.min\.(?:js|mjs|cjs)$/u;
+const MINIFIED_BYTES = 10_240;
+const MINIFIED_LINE = 500;
+
+/** Whether one name is a minified file's, which decides it without its text. */
+export function minifiedByName(fileName: string): boolean {
+  return MINIFIED_NAME.test(fileName);
+}
+
+/** Whether one JavaScript file is minified: by its name, or by its text's size and mean line length. */
+export function minified(fileName: string, text: string): boolean {
+  if (!JAVASCRIPT_FILE.test(fileName)) {
+    return false;
+  }
+  if (minifiedByName(fileName)) {
+    return true;
+  }
+  // A UTF-16 unit encodes to at most three UTF-8 bytes, so a shorter text is below the size.
+  if (text.length * 3 < MINIFIED_BYTES) {
+    return false;
+  }
+  const lines = text.split(/\r?\n/u).length;
+  return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE;
+}
+
+/** The length of a text in UTF-8, a lone surrogate counting as the three bytes of U+FFFD. */
+function utf8Bytes(text: string): number {
+  let bytes = 0;
+  for (const character of text) {
+    const point = character.codePointAt(0) ?? 0;
+    bytes += point < 0x80 ? 1 : point < 0x800 ? 2 : point < 0x10000 ? 3 : 4;
+  }
+  return bytes;
+}