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

package/dist/src/exemptions/sites.js

@@ -0,0 +1,182 @@
+/**
+ * The one walk of a project's own files every detector shares: its calls and the class
+ * `this` stands for at each, its classes, the values it hands to positions typed by
+ * their context, its functions' parameters, its decorated declarations and its
+ * assignments to properties. The walk reads syntax only; what a call invokes through a
+ * method of `Function.prototype` asks the checker, once per project, at the first
+ * detector that needs it.
+ */
+import { isArrowFunction, isBinaryExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isElementAccessExpression, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyDeclaration, isSetAccessorDeclaration, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/ast";
+import { handedOn, valuesOf } from "../index/values.js";
+import { isParameterProperty, nodeKey } from "../inventory.js";
+import { parenthesesRemoved } from "../unwrap.js";
+import { decoratorsOf, invocations } from "./calls.js";
+/** The property one assignment's left side names on its receiver, where a written key names it. */
+function storeOf(node) {
+    if (!isBinaryExpression(node) || node.operatorToken.kind !== SyntaxKind.EqualsToken) {
+        return undefined;
+    }
+    const left = parenthesesRemoved(node.left);
+    if (isPropertyAccessExpression(left) && isIdentifier(left.name)) {
+        return { store: node, receiver: left.expression, key: left.name.text, value: node.right };
+    }
+    if (isElementAccessExpression(left) &&
+        (isStringLiteral(left.argumentExpression) ||
+            isNoSubstitutionTemplateLiteral(left.argumentExpression))) {
+        return {
+            store: node,
+            receiver: left.expression,
+            key: left.argumentExpression.text,
+            value: node.right,
+        };
+    }
+    return undefined;
+}
+/** Whether one node declares a static member, whose `this` is the class itself. */
+function isStatic(node) {
+    const flags = node.modifierFlags ?? 0;
+    return (flags & ModifierFlags.Static) !== 0;
+}
+/**
+ * Whether one node opens a body whose `this` is no instance of the enclosing class: a
+ * function that is not an arrow, a static block, a static member, and a method or an
+ * accessor of an object literal, whose `this` is the literal.
+ */
+function resetsThis(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isClassStaticBlockDeclaration(node) ||
+        isStatic(node) ||
+        ((isMethodDeclaration(node) ||
+            isGetAccessorDeclaration(node) ||
+            isSetAccessorDeclaration(node)) &&
+            isObjectLiteralExpression(node.parent)));
+}
+/** The parameters and declaring node of one function-like declaration of the project. */
+function functionOf(node) {
+    if (isFunctionDeclaration(node) ||
+        (isMethodDeclaration(node) && !isObjectLiteralExpression(node.parent))) {
+        return { declared: node, parameters: node.parameters };
+    }
+    if (isVariableDeclaration(node) &&
+        node.initializer !== undefined &&
+        (isArrowFunction(node.initializer) || isFunctionExpression(node.initializer))) {
+        return { declared: node, parameters: node.initializer.parameters };
+    }
+    return undefined;
+}
+function walk(project, held) {
+    const calls = [];
+    const classes = [];
+    const flows = [];
+    const parameters = [];
+    const decorated = [];
+    const stores = [];
+    const parameterProperties = new Set();
+    const initialized = new Set();
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node, self) => {
+            const id = held.declarations.get(nodeKey(file, node));
+            let inner = self;
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                inner = id;
+                if (id !== undefined) {
+                    classes.push({ id, node });
+                }
+            }
+            else if (resetsThis(node)) {
+                inner = undefined;
+            }
+            if (id !== undefined) {
+                if (isParameterProperty(node)) {
+                    parameterProperties.add(id);
+                }
+                if (decoratorsOf(node).length > 0) {
+                    decorated.push({ id, node });
+                }
+                if (isPropertyDeclaration(node) && node.initializer !== undefined) {
+                    initialized.add(id);
+                }
+            }
+            if (node.kind === SyntaxKind.CallExpression) {
+                calls.push({ call: node, self: inner });
+            }
+            const store = storeOf(node);
+            if (store !== undefined) {
+                stores.push(store);
+            }
+            for (const written of handedOn(node)) {
+                for (const value of valuesOf(written)) {
+                    flows.push({ value, self: value.kind === SyntaxKind.ThisKeyword ? inner : undefined });
+                }
+            }
+            const fn = functionOf(node);
+            const fnId = fn === undefined ? undefined : held.declarations.get(nodeKey(file, fn.declared));
+            if (fn !== undefined && fnId !== undefined) {
+                fn.parameters
+                    .filter((parameter) => !(isIdentifier(parameter.name) && parameter.name.text === "this"))
+                    .forEach((parameter, index) => {
+                    if (isIdentifier(parameter.name)) {
+                        parameters.push({
+                            fn: fnId,
+                            index,
+                            rest: parameter.dotDotDotToken !== undefined,
+                            name: parameter.name,
+                        });
+                    }
+                });
+            }
+            node.forEachChild((child) => {
+                visit(child, inner);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, undefined);
+        });
+    }
+    return {
+        calls,
+        classes,
+        flows,
+        parameters,
+        decorated,
+        stores,
+        parameterProperties,
+        initialized,
+    };
+}
+/** The sites of one project's own files, each walk and each checker question made once. */
+export function projectSites(project, held) {
+    let walked;
+    let invoked;
+    const sites = () => (walked ??= walk(project, held));
+    return {
+        get calls() {
+            return sites().calls;
+        },
+        get classes() {
+            return sites().classes;
+        },
+        get flows() {
+            return sites().flows;
+        },
+        get parameters() {
+            return sites().parameters;
+        },
+        get decorated() {
+            return sites().decorated;
+        },
+        get stores() {
+            return sites().stores;
+        },
+        get parameterProperties() {
+            return sites().parameterProperties;
+        },
+        get initialized() {
+            return sites().initialized;
+        },
+        get invocations() {
+            return (invoked ??= invocations(project, sites().calls.map((one) => one.call)));
+        },
+    };
+}

package/dist/src/{template-field.js → exemptions/template-field.js}

@@ -11,11 +11,13 @@
  * instance members of classes and the members of interfaces and object types, on any
  * type, because nothing ties the name to a type.
  */
-import { readComponent } from "./component-files.js";
-import { ConfigError } from "./config.js";
-import { memberNames } from "./member-names.js";
-import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
-import { isComponentFile } from "./position.js";
+import { readComponent } from "../component-files.js";
+import { memberNames } from "../member-names.js";
+import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "../paths.js";
+import { isComponentFile } from "../position.js";
+import { bytewise } from "../text/compare.js";
+import { filesBelow } from "../fs/tree.js";
+import { UsageError } from "../usage.js";
 /** The kinds of declaration an action can name. */
 const READ_BY_A_TEMPLATE = new Set([
     "method",
@@ -30,13 +32,6 @@ const READ_BY_A_TEMPLATE = new Set([
 const READ_BY_MARKUP = new Set([...READ_BY_A_TEMPLATE, "enum-member"]);
 /** One identifier, as the grammar of the analyzed language spells one. */
 const IDENTIFIER = /[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*/uy;
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * Every template under the configured directories, read once for the run, in path
  * order and each file once. A directory is named relative to the target root, and
@@ -48,34 +43,29 @@ function compare(a, b) {
 export function readTemplates(host, targetRoot, analysis) {
     const files = new Map();
     const read = (dir) => {
-        const entries = [...host.readDirectory(joinPath(targetRoot, dir))].sort((a, b) => compare(a.name, b.name));
-        for (const entry of entries) {
-            const path = joinPath(dir, entry.name);
-            if (entry.directory) {
-                read(path);
-                continue;
-            }
+        for (const below of filesBelow(host, joinPath(targetRoot, dir), () => true)) {
+            const path = joinPath(dir, below);
             const absolute = joinPath(targetRoot, path);
             if (!files.has(path) && host.kindOf(absolute) === "file") {
                 files.set(path, host.readFile(absolute));
             }
         }
     };
-    for (const configured of analysis.templateDirs) {
+    for (const configured of analysis.template_dirs) {
         const dir = normalizePath(configured);
         if (isAbsolutePath(dir) ||
             dir === ".." ||
             dir.startsWith("../") ||
             host.kindOf(joinPath(targetRoot, dir)) !== "directory") {
-            throw new ConfigError("malformed", "analysis.template_dirs", `analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
+            throw new UsageError(`analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
         }
         read(dir);
     }
     return {
-        delimiters: analysis.templateDelimiters,
+        delimiters: analysis.template_delimiters,
         files: [...files]
             .map(([path, text]) => ({ path, text }))
-            .sort((a, b) => compare(a.path, b.path)),
+            .sort((a, b) => bytewise(a.path, b.path)),
     };
 }
 /** The end of the quoted string that opens at `from`, past its closing quote. */

package/dist/src/{value-reach.js → exemptions/value-reach.js}

@@ -2,14 +2,15 @@
  * The classes of the target a value of one type carries, and the members of the other
  * object types the target writes that it carries, as a serializer walking the value reaches
  * them: through constituents, array and tuple elements, the data members and index
- * signatures of the types the target writes, and the values `stored` gives for a type where
- * it erases them. The walk stops at `any`, `unknown`, a type parameter, a function and an
- * interface or class of another program, so an instance held only there is missed.
+ * signatures of the types the target writes, a class's polymorphic `this` type, and the values
+ * `stored` gives for a type where it erases them. The walk stops at `any`, `unknown`, any
+ * other type parameter, a function and an interface or class of another program, so an
+ * instance held only there is missed.
  */
 import { isAsExpression, isParenthesizedExpression, isSatisfiesExpression, isTypeAssertion, } from "@typescript/native/ast";
-import { ObjectFlags, SymbolFlags, } from "@typescript/native/sync";
-import { classNames, typesAt } from "./class-members.js";
-import { must } from "./query.js";
+import { ObjectFlags, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
+import { classNames, typesAt } from "../class-members.js";
+import { must } from "../query.js";
 /**
  * The object types whose members the walk reads whatever declares them. A reverse-mapped
  * type has no symbol: it is the shape the checker infers from an argument the target
@@ -19,7 +20,9 @@ const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped | ObjectFlags.Rev
 /** The symbols of an anonymous object type the target writes as a type. */
 const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
 /** The two conversion methods a serializer or a formatter resolves on a value's own shape. */
-const CONVERSION_NAMES = new Set(["toJSON", "toString"]);
+export const CONVERSION_NAMES = new Set(["toJSON", "toString"]);
+/** The types that keep nothing of a value they are given, or that a decode gives a value. */
+export const ERASED = TypeFlags.Any | TypeFlags.Unknown;
 /**
  * The members that can answer a conversion: a serializer reads the name with `[[Get]]`
  * and calls what it answers, so a getter answers it as a method does:
@@ -140,6 +143,10 @@ export function valueReach(project, held, stored = () => []) {
         if (type.isUnionType() || type.isIntersectionType()) {
             found = must(queries.constituents(type));
         }
+        else if (type.isTypeParameter() && type.isThisType === true) {
+            // A value of a class's polymorphic `this` type is an instance of the class.
+            found = [must(queries.constraintOf(type))].filter((one) => one !== undefined);
+        }
         else if (type.isObjectType()) {
             const target = targetOf(type);
             const isList = type.isTypeReference() &&