@cplieger/deadset-ts 5.0.0 → 5.1.0

package/src/resolve.ts

@@ -262,18 +262,19 @@ function readStrings<T extends string>(
     );
   }
   const seen = new Set<string>();
-  for (const entry of value as unknown[]) {
+  for (const [index, entry] of (value as unknown[]).entries()) {
+    const at = `${path}[${String(index)}]`;
     if (typeof entry !== "string") {
-      throw malformed(label, path, "holds an entry that is not a string");
+      throw malformed(label, at, "is not a string");
     }
     if (entry === "") {
-      throw malformed(label, path, "holds an empty entry");
+      throw malformed(label, at, "is empty");
     }
     if (seen.has(entry)) {
-      throw malformed(label, path, `names ${JSON.stringify(entry)} twice`);
+      throw malformed(label, at, `names ${JSON.stringify(entry)} again`);
     }
     if (allowed !== undefined && !(allowed as readonly string[]).includes(entry)) {
-      throw malformed(label, path, `${JSON.stringify(entry)} is not one of ${spell(allowed)}`);
+      throw malformed(label, at, `${JSON.stringify(entry)} is not one of ${spell(allowed)}`);
     }
     seen.add(entry);
   }
@@ -288,12 +289,12 @@ function readComponentExtensions(
   label: string,
 ): readonly string[] | undefined {
   const extensions = readStrings(ts, "component_extensions", "ts.component_extensions", label, 0);
-  const wrong = extensions?.find((one) => !COMPONENT_EXTENSION.test(one));
-  if (wrong !== undefined) {
+  const wrong = extensions?.findIndex((one) => !COMPONENT_EXTENSION.test(one)) ?? -1;
+  if (extensions !== undefined && wrong !== -1) {
     throw malformed(
       label,
-      "ts.component_extensions",
-      `${JSON.stringify(wrong)} is not a full stop followed by letters and digits`,
+      `ts.component_extensions[${String(wrong)}]`,
+      `${JSON.stringify(extensions[wrong])} is not a full stop followed by letters and digits`,
     );
   }
   return extensions;
@@ -307,12 +308,12 @@ function readDisabledConventions(
   label: string,
 ): readonly string[] | undefined {
   const names = readStrings(ts, "disabled_conventions", "ts.disabled_conventions", label, 0);
-  const unknown = names?.find((one) => !CONVENTION_NAMES.has(one));
-  if (unknown !== undefined) {
+  const unknown = names?.findIndex((one) => !CONVENTION_NAMES.has(one)) ?? -1;
+  if (names !== undefined && unknown !== -1) {
     throw malformed(
       label,
-      "ts.disabled_conventions",
-      `${JSON.stringify(unknown)} names no convention row this analyzer carries`,
+      `ts.disabled_conventions[${String(unknown)}]`,
+      `${JSON.stringify(names[unknown])} names no convention row this analyzer carries`,
     );
   }
   return names;

package/src/roots.ts

@@ -10,6 +10,7 @@
 
 import type { SourceFile } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.ts";
+import type { ParseFile } from "./configuration-files.ts";
 import { conventionEntries, type Conventions } from "./conventions.ts";
 import { entryPoints, type EntryRule } from "./entry-points.ts";
 import { globExpression } from "./glob.ts";
@@ -112,6 +113,8 @@ export interface RootOptions {
   readonly conventions?: Conventions | undefined;
   /** `ts.test_files` from the resolved configuration. */
   readonly testFiles: readonly string[];
+  /** The parser the configuration files no program holds are read with, where they are read. */
+  readonly parse?: ParseFile | undefined;
   /** Whether the target is a library, so a consumer outside it reaches its published API. */
   readonly publishedAPI: boolean;
 }
@@ -268,7 +271,14 @@ export function roots<Brand>(
     : conventionEntries(options.conventions, files)) {
     enter(file, "convention", row, true);
   }
-  for (const point of entryPoints(project, files, options.testFiles, options.host, targetRoot)) {
+  for (const point of entryPoints(
+    project,
+    files,
+    options.testFiles,
+    options.host,
+    targetRoot,
+    options.parse,
+  )) {
     enter(point.file, point.rule, point.source, point.exports);
   }
   for (const file of files.byPath.values()) {

package/src/stores.ts

@@ -22,6 +22,8 @@ export interface Stores {
    * configuration. A production mode counts none a test file made.
    */
   readonly references: readonly Reference[];
+  /** The declarations a test file reads, which a production mode counts no read of. */
+  readonly readInTests: ReadonlySet<string>;
   /**
    * The class members declared by a getter or a setter. A store into one runs the
    * setter, which is code rather than state.
@@ -71,6 +73,13 @@ export function storesOf(
     references: per.flatMap((one) =>
       one.references.filter((reference) => !mode.production || !reference.test),
     ),
+    readInTests: new Set(
+      per.flatMap((one) =>
+        one.references
+          .filter((reference) => reference.test && reference.use !== "write")
+          .map((reference) => reference.to),
+      ),
+    ),
     accessors: new Set(per.flatMap((one) => one.accessors)),
     exempt: new Set(exempt.map((record) => record.id)),
   };

package/src/value-flow.ts

@@ -0,0 +1,104 @@
+/**
+ * The values a program hands to a position the checker types from its context: the
+ * initializer of a declaration whose type is written, an assignment's right side, an
+ * argument, a returned value, an arrow function's expression body, an array element, an
+ * object property, and the operand of `as` or `satisfies`.
+ */
+
+import {
+  isArrayLiteralExpression,
+  isArrowFunction,
+  isAsExpression,
+  isBinaryExpression,
+  isCallExpression,
+  isConditionalExpression,
+  isIdentifier,
+  isNewExpression,
+  isParameterDeclaration,
+  isParenthesizedExpression,
+  isPropertyAssignment,
+  isPropertyDeclaration,
+  isReturnStatement,
+  isSatisfiesExpression,
+  isShorthandPropertyAssignment,
+  isSpreadElement,
+  isVariableDeclaration,
+  SyntaxKind,
+  type Expression,
+  type Node,
+} from "@typescript/native/unstable/ast";
+
+/** The operators of an assignment whose right side is stored into the left side's type. */
+const STORES: ReadonlySet<SyntaxKind> = new Set([
+  SyntaxKind.EqualsToken,
+  SyntaxKind.QuestionQuestionEqualsToken,
+  SyntaxKind.BarBarEqualsToken,
+  SyntaxKind.AmpersandAmpersandEqualsToken,
+]);
+
+/** Whether a declaration writes its type, so its initializer is read in that type's context. */
+function writesType(node: Node): boolean {
+  return (node as { readonly type?: Node }).type !== undefined;
+}
+
+/**
+ * The values one written expression hands on: the expression itself, or what it
+ * evaluates to through parentheses, a conditional and the operators whose result is
+ * one of their operands.
+ */
+export function valuesOf(expression: Expression): readonly Expression[] {
+  if (isParenthesizedExpression(expression)) {
+    return valuesOf(expression.expression);
+  }
+  if (isConditionalExpression(expression)) {
+    return [...valuesOf(expression.whenTrue), ...valuesOf(expression.whenFalse)];
+  }
+  if (isBinaryExpression(expression)) {
+    const operator = expression.operatorToken.kind;
+    if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
+      return [...valuesOf(expression.left), ...valuesOf(expression.right)];
+    }
+    if (operator === SyntaxKind.AmpersandAmpersandToken || operator === SyntaxKind.CommaToken) {
+      return valuesOf(expression.right);
+    }
+  }
+  return [expression];
+}
+
+/** The expressions one node hands to a position typed by its context. */
+export function handedOn(node: Node): readonly Expression[] {
+  if (
+    (isVariableDeclaration(node) || isPropertyDeclaration(node) || isParameterDeclaration(node)) &&
+    node.initializer !== undefined &&
+    writesType(node)
+  ) {
+    return [node.initializer];
+  }
+  if (isBinaryExpression(node) && STORES.has(node.operatorToken.kind)) {
+    return [node.right];
+  }
+  if (isCallExpression(node) || isNewExpression(node)) {
+    return (node.arguments ?? []).filter((argument) => !isSpreadElement(argument));
+  }
+  if (isReturnStatement(node)) {
+    return node.expression === undefined ? [] : [node.expression];
+  }
+  if (isArrowFunction(node)) {
+    return node.body.kind === SyntaxKind.Block ? [] : [node.body];
+  }
+  if (isArrayLiteralExpression(node)) {
+    return node.elements.filter(
+      (element) => !isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression,
+    );
+  }
+  if (isPropertyAssignment(node)) {
+    return [node.initializer];
+  }
+  if (isShorthandPropertyAssignment(node)) {
+    return isIdentifier(node.name) ? [node.name] : [];
+  }
+  if (isAsExpression(node) || isSatisfiesExpression(node)) {
+    return [node.expression];
+  }
+  return [];
+}

package/src/version.ts

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "5.1.0";
+export const CONTRACT_VERSION = "5.2.0";