ucn 5.5.2 → 5.6.0

package/languages/javascript.js

@@ -1665,6 +1665,18 @@ function extractInterfaceMembers(interfaceNode, code) {
     return extractTypeMembers(bodyNode, code);
 }
 
+/**
+ * A signature in an interface or object type is a member every value of
+ * that type must have, unless it is written optional (`name?`). The `?` is
+ * a token of the signature node, never part of the name or the type.
+ */
+function isOptionalSignature(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        if (node.child(i).type === '?') return true;
+    }
+    return false;
+}
+
 function extractTypeMembers(bodyNode, code) {
     const members = [];
     for (let i = 0; i < bodyNode.namedChildCount; i++) {
@@ -1687,6 +1699,7 @@ function extractTypeMembers(bodyNode, code) {
                     sourceSpan,
                     memberType: 'method',
                     isMethod: true,
+                    ...(!isOptionalSignature(child) && { requiredMember: true }),
                     ...typeAnno
                 });
             }
@@ -1706,6 +1719,7 @@ function extractTypeMembers(bodyNode, code) {
                     endLine,
                     sourceSpan,
                     memberType: 'field',
+                    ...(!isOptionalSignature(child) && { requiredMember: true }),
                     ...(fieldType && { fieldType })
                 });
             }
@@ -1908,6 +1922,9 @@ function extractClassMembers(classNode, codeOrLines) {
                     sourceSpan,
                     memberType: 'abstract',
                     isMethod: true,
+                    // A concrete subclass must supply it (an optional
+                    // abstract member is not a thing the language has).
+                    requiredMember: true,
                     ...typeAnno,
                     ...(docstring && { docstring }),
                     ...(decorators.length > 0 && { decorators })
@@ -2234,13 +2251,42 @@ function jsModuleValueAliases(root) {
     // A `let`/`var` alias is the class only while nothing assigns the
     // name again (fix #392): any write to that identifier anywhere in the
     // module, or a second declaration, leaves it unbound.
+    // A write inside a function or block that declares the name itself
+    // (`class Local {}; Local = f`, a parameter, a `let`) writes that
+    // declaration, never the module's binding of the same name: only names
+    // the module declares need the scope walk.
+    const moduleNames = new Set();
+    for (let statement of root.namedChildren) {
+        if (statement.type === 'export_statement') statement = statement.childForFieldName('declaration') || statement;
+        if (statement.type === 'import_statement') {
+            for (const name of statement.descendantsOfType('identifier')) moduleNames.add(name.text);
+        } else if (statement.type === 'lexical_declaration' || statement.type === 'variable_declaration') {
+            for (const declarator of statement.namedChildren) {
+                const target = declarator.type === 'variable_declarator' ? declarator.childForFieldName('name') : null;
+                if (!target) continue;
+                if (target.type === 'identifier') moduleNames.add(target.text);
+                else for (const name of target.descendantsOfType(['identifier', 'shorthand_property_identifier_pattern'])) moduleNames.add(name.text);
+            }
+        } else {
+            const name = statement.childForFieldName?.('name');
+            if (name?.type === 'identifier' || name?.type === 'type_identifier') moduleNames.add(name.text);
+        }
+    }
     const written = new Set();
+    const scopes = new Map();
+    const write = (node) => {
+        if (moduleNames.has(node.text) && !written.has(node.text)) {
+            const verdict = referenceScope(node, 'javascript', scopes);
+            if (verdict && typeof verdict === 'object' && verdict.local) return;
+        }
+        written.add(node.text);
+    };
     const writeTargets = (node) => {
         if (!node) return;
-        if (node.type === 'identifier') { written.add(node.text); return; }
+        if (node.type === 'identifier') { write(node); return; }
         if (/pattern$/.test(node.type) || node.type === 'pair_pattern' ||
             node.type === 'shorthand_property_identifier_pattern') {
-            if (node.type === 'shorthand_property_identifier_pattern') written.add(node.text);
+            if (node.type === 'shorthand_property_identifier_pattern') write(node);
             for (const child of node.namedChildren) writeTargets(child);
         }
     };
@@ -5861,6 +5907,1121 @@ const _JS_LIFECYCLE_METHODS = new Set([
     'connectedCallback', 'disconnectedCallback', 'attributeChangedCallback', 'adoptedCallback'
 ]);
 
+
+// The functions JavaScript runners declare tests with (mocha, jest, vitest,
+// node:test and the runners that copy them).
+const TEST_SUITE_APIS = new Set(['describe', 'suite', 'context', 'xdescribe', 'fdescribe', 'xcontext']);
+const TEST_CASE_APIS = new Set(['it', 'test', 'specify', 'xit', 'fit', 'xtest', 'xspecify']);
+// Members that keep a call a declaration of the same thing.
+const TEST_API_MODIFIERS = new Set(['only', 'skip', 'todo', 'concurrent', 'sequential', 'serial', 'parallel',
+    'failing', 'fails', 'fixme', 'slow']);
+// Members whose call returns the declaring function: it.each(rows)(title, fn).
+const TEST_API_TABLES = new Set(['each', 'for']);
+const TEST_API_CONDITIONS = new Set(['runIf', 'skipIf', 'if']);
+const FUNCTION_NODES = new Set(['function_declaration', 'function_expression', 'function', 'arrow_function',
+    'generator_function', 'generator_function_declaration', 'method_definition']);
+// Modules whose import says which runner executes a test file.
+const TEST_RUNNER_MODULES = new Map([
+    ['node:test', 'node-test'], ['test', 'node-test'],
+    ['vitest', 'vitest'],
+    ['@jest/globals', 'jest'],
+    ['mocha', 'mocha'],
+    ['bun:test', 'bun'], ['@playwright/test', 'playwright'], ['ava', 'ava'], ['tap', 'tap'],
+    ['uvu', 'uvu'], ['@japa/runner', 'japa'], ['cypress', 'cypress'], ['tape', 'tape'],
+]);
+// Modules whose default export is itself the function that declares a test.
+const TEST_CALLABLE_MODULES = new Set(['node:test', 'test', 'ava', 'tape']);
+// Functions the runners call before the tests of a suite or of a file.
+const TEST_SETUP_HOOKS = new Set(['before', 'beforeEach', 'beforeAll', 'suiteSetup', 'setup']);
+// Objects every script can read the runner's globals from.
+const GLOBAL_OBJECTS = new Set(['globalThis', 'global', 'window', 'self']);
+const WRAPPERS = new Set(['parenthesized_expression', 'as_expression', 'non_null_expression',
+    'satisfies_expression', 'await_expression', 'type_assertion']);
+
+function isTestApiName(name) {
+    return TEST_SUITE_APIS.has(name) || TEST_CASE_APIS.has(name);
+}
+
+const BLOCK_SCOPES = new Set(['statement_block', 'for_statement', 'for_in_statement', 'catch_clause', 'switch_body']);
+const CLASS_NODES = new Set(['class_declaration', 'abstract_class_declaration', 'class']);
+// Declarations that exist for the type checker only.
+const AMBIENT_NODES = new Set(['ambient_declaration', 'type_alias_declaration', 'interface_declaration',
+    'function_signature']);
+const DECLARING = new Set(['import_statement', 'lexical_declaration', 'variable_declaration',
+    'function_declaration', 'generator_function_declaration', 'class_declaration', 'export_statement']);
+// Values that are no function at all.
+const PLAIN_VALUES = new Set(['number', 'string', 'template_string', 'true', 'false', 'null', 'undefined', 'regex']);
+const BUILT_VALUES = new Set(['object', 'array', 'class', 'new_expression']);
+const OTHER = Object.freeze({ other: true });
+const UNREAD = Object.freeze({ unread: true });
+// The nodes the binder does something at; any other is only walked through.
+const BINDER_NODES = new Set([...AMBIENT_NODES, ...FUNCTION_NODES, ...CLASS_NODES, ...BLOCK_SCOPES,
+    'class_static_block', 'with_statement', 'import_statement', 'lexical_declaration', 'variable_declaration',
+    'enum_declaration', 'internal_module', 'module', 'assignment_expression', 'augmented_assignment_expression',
+    'update_expression', 'call_expression']);
+
+/** Every name a binding pattern introduces. */
+function patternNames(pattern, out = []) {
+    if (!pattern) return out;
+    switch (pattern.type) {
+        case 'identifier': case 'shorthand_property_identifier_pattern':
+            out.push(pattern.text);
+            return out;
+        case 'assignment_pattern': case 'object_assignment_pattern':
+            return patternNames(pattern.childForFieldName('left'), out);
+        case 'pair_pattern':
+            return patternNames(pattern.childForFieldName('value'), out);
+        case 'required_parameter': case 'optional_parameter':
+            return patternNames(pattern.childForFieldName('pattern'), out);
+        case 'object_pattern': case 'array_pattern': case 'rest_pattern': case 'formal_parameters':
+            for (const child of pattern.namedChildren) patternNames(child, out);
+            return out;
+        default:
+            return out;
+    }
+}
+
+/**
+ * What names are bound to, as far as declaring tests goes, by the rules of
+ * the language's own scopes, read once for the whole file. A name belongs
+ * to the scope that declares it: `var` and a function declaration to the
+ * function around them wherever they stand in it, `let`, `const` and a
+ * class to their block, a parameter, a caught value and a loop variable to
+ * what they head. Every write to a name counts, wherever it stands: the
+ * declaration, an assignment (in a nested function too), a destructuring
+ * assignment, an update. A name written once holds that value; a name
+ * written more than once holds a value only when every write gives the
+ * same one, else it is not read. A name no scope of the file binds is the
+ * runner's global when it is spelled like one, unless the file writes that
+ * global or hands the global object to something. Inside `with`, and in a
+ * function that calls `eval`, names can be bound at run time: not read.
+ *
+ * A value is the runner's function under any name ({ api }), a module or
+ * object its functions are read from ({ namespace }), something that is
+ * provably neither ({ other }; `calls` says whether it is a function), or
+ * something this cannot read ({ unread }): a call through the last two is
+ * no test. "helpers.exported(module, name)" says what a project module
+ * exports under a name.
+ */
+function createTestBinder(helpers, root) {
+    const literal = node => node && node.type === 'string' ? node.text.slice(1, -1) : null;
+    const scopes = new Map(); // id of the node that opens a scope -> scope
+    // Every call of the file in source order, with the scope it stands in
+    // and the function it stands in; every function, with the one around it.
+    const calls = [];
+    const functions = new Map();
+    const pending = [];
+    const writtenGlobals = new Set();
+    let globalsHandedOver = false;
+    const newScope = parent => ({ parent, names: new Map(), dynamic: false });
+    const bindingIn = (scope, name) => {
+        let binding = scope.names.get(name);
+        if (!binding) {
+            binding = { name, writes: [] };
+            scope.names.set(name, binding);
+        }
+        return binding;
+    };
+    const lookup = (scope, name) => {
+        for (let current = scope; current; current = current.parent) {
+            const binding = current.names.get(name);
+            if (binding) return { binding };
+            if (current.dynamic) return { dynamic: true };
+        }
+        return null;
+    };
+    const top = newScope(null);
+    const fixed = value => ({ kind: 'fixed', value });
+
+    const declarePattern = (target, pattern, value, env) => {
+        if (!pattern) return;
+        if (pattern.type === 'identifier') {
+            const binding = bindingIn(target, pattern.text);
+            if (value) binding.writes.push({ kind: 'value', node: value, env });
+            return;
+        }
+        if (pattern.type !== 'object_pattern') {
+            for (const name of patternNames(pattern)) bindingIn(target, name).writes.push({ kind: 'unknown', node: value, env });
+            return;
+        }
+        for (const property of pattern.namedChildren) {
+            let key = null;
+            let local = null;
+            if (property.type === 'shorthand_property_identifier_pattern') {
+                key = local = property.text;
+            } else if (property.type === 'pair_pattern') {
+                const keyNode = property.childForFieldName('key');
+                const valueNode = property.childForFieldName('value');
+                if (keyNode && keyNode.type !== 'computed_property_name') key = keyNode.text.replace(/^['"]|['"]$/g, '');
+                if (valueNode && valueNode.type === 'identifier') local = valueNode.text;
+            }
+            if (key && local) bindingIn(target, local).writes.push({ kind: 'member', node: value, env, key });
+            else for (const name of patternNames(property)) bindingIn(target, name).writes.push({ kind: 'unknown', node: value, env });
+        }
+    };
+
+    const declareImport = (node, scope) => {
+        // `import type` binds no value.
+        if (node.children.some(child => child.type === 'type')) return;
+        const required = node.namedChildren.find(child => child.type === 'import_require_clause');
+        if (required) {
+            const local = required.namedChildren.find(child => child.type === 'identifier');
+            const from = literal(required.namedChildren.find(child => child.type === 'string'));
+            if (local) bindingIn(scope, local.text).writes.push({ kind: 'import', module: from, imported: null });
+            return;
+        }
+        const moduleName = literal(node.childForFieldName('source'));
+        const clause = node.namedChildren.find(child => child.type === 'import_clause');
+        for (const part of (clause && clause.namedChildren) || []) {
+            if (part.type === 'identifier') {
+                // A default import: the runner module itself where its
+                // default is the declaring function.
+                bindingIn(scope, part.text).writes.push({
+                    kind: 'import', module: moduleName,
+                    imported: TEST_RUNNER_MODULES.has(moduleName) ? null : 'default',
+                });
+            } else if (part.type === 'namespace_import') {
+                const local = part.namedChildren.find(child => child.type === 'identifier');
+                if (local) bindingIn(scope, local.text).writes.push({ kind: 'import', module: moduleName, imported: null });
+            } else if (part.type === 'named_imports') {
+                for (const spec of part.namedChildren) {
+                    const imported = spec.childForFieldName('name');
+                    const alias = spec.childForFieldName('alias');
+                    if (!imported || spec.children.some(child => child.type === 'type')) continue;
+                    bindingIn(scope, (alias || imported).text).writes.push({
+                        kind: 'import', module: moduleName, imported: imported.text,
+                    });
+                }
+            }
+        }
+    };
+
+    const buildFunction = (node, scope, varScope, around) => {
+        const fn = { parent: around };
+        functions.set(node.id, fn);
+        const declaration = node.type === 'function_declaration' || node.type === 'generator_function_declaration';
+        const name = node.childForFieldName('name');
+        let outer = scope;
+        if (declaration && name) {
+            if (scope === varScope || scope.bodyOf === varScope) {
+                // Hoisted: one binding with the function's `var`s.
+                bindingIn(varScope, name.text).writes.push(fixed({ other: true, calls: true }));
+            } else {
+                // In a block: the block's own, and outside it too where
+                // the file is not strict (not decided here).
+                bindingIn(scope, name.text).writes.push(fixed({ other: true, calls: true }));
+                bindingIn(varScope, name.text).writes.push({ kind: 'maybe', outer: varScope.parent });
+            }
+        } else if (name && node.type !== 'method_definition') {
+            // The name of a function expression is its own, inside it.
+            outer = newScope(scope);
+            bindingIn(outer, name.text).writes.push(fixed({ other: true, calls: true }));
+        }
+        const own = newScope(outer);
+        scopes.set(node.id, own);
+        const parameters = node.childForFieldName('parameters') || node.childForFieldName('parameter');
+        for (const parameter of patternNames(parameters)) bindingIn(own, parameter).writes.push({ kind: 'parameter' });
+        if (parameters) for (const child of parameters.namedChildren) build(child, own, own, fn);
+        const body = node.childForFieldName('body');
+        if (body && body.type === 'statement_block') {
+            const inner = newScope(own);
+            inner.bodyOf = own;
+            scopes.set(body.id, inner);
+            for (const child of body.namedChildren) build(child, inner, own, fn);
+        } else if (body) {
+            build(body, own, own, fn);
+        }
+    };
+
+    const build = (node, scope, varScope, fn) => {
+        // A node with nothing inside declares, writes and calls nothing;
+        // most others only hold the ones that do.
+        if (node.namedChildCount === 0) return;
+        const type = node.type;
+        if (!BINDER_NODES.has(type)) {
+            for (const child of node.namedChildren) build(child, scope, varScope, fn);
+            return;
+        }
+        if (AMBIENT_NODES.has(type)) return;
+        if (FUNCTION_NODES.has(type)) {
+            buildFunction(node, scope, varScope, fn);
+            return;
+        }
+        if (CLASS_NODES.has(type)) {
+            const name = node.childForFieldName('name');
+            let inner = scope;
+            if (name && type === 'class') {
+                inner = newScope(scope);
+                scopes.set(node.id, inner);
+                bindingIn(inner, name.text).writes.push(fixed(OTHER));
+            } else if (name) {
+                bindingIn(scope, name.text).writes.push(fixed(OTHER));
+            }
+            for (const child of node.namedChildren) build(child, inner, varScope, fn);
+            return;
+        }
+        if (type === 'class_static_block') {
+            const own = newScope(scope);
+            scopes.set(node.id, own);
+            for (const child of node.namedChildren) build(child, own, own, fn);
+            return;
+        }
+        if (BLOCK_SCOPES.has(type)) {
+            const own = newScope(scope);
+            scopes.set(node.id, own);
+            if (type === 'catch_clause') {
+                for (const name of patternNames(node.childForFieldName('parameter'))) {
+                    bindingIn(own, name).writes.push(fixed(OTHER));
+                }
+            } else if (type === 'for_in_statement') {
+                const left = node.childForFieldName('left');
+                const kind = node.childForFieldName('kind');
+                const names = left && left.type === 'identifier' ? [left.text] : patternNames(left);
+                const from = { kind: 'unknown', node: node.childForFieldName('right'), env: scope };
+                for (const name of names) {
+                    if (!kind) pending.push({ name, scope, write: from });
+                    else bindingIn(kind.text === 'var' ? varScope : own, name).writes.push(from);
+                }
+            }
+            for (const child of node.namedChildren) build(child, own, varScope, fn);
+            return;
+        }
+        if (type === 'with_statement') {
+            // Any name inside may be a property of the object.
+            const own = newScope(scope);
+            own.dynamic = true;
+            scopes.set(node.id, own);
+            for (const child of node.namedChildren) build(child, own, varScope, fn);
+            return;
+        }
+        if (type === 'import_statement') {
+            declareImport(node, scope);
+            return;
+        }
+        if (type === 'lexical_declaration' || type === 'variable_declaration') {
+            const target = type === 'variable_declaration' ? varScope : scope;
+            for (const declarator of node.namedChildren) {
+                if (declarator.type !== 'variable_declarator') continue;
+                const value = declarator.childForFieldName('value');
+                declarePattern(target, declarator.childForFieldName('name'), value, scope);
+                if (value) build(value, scope, varScope, fn);
+            }
+            return;
+        }
+        if (type === 'enum_declaration' || type === 'internal_module' || type === 'module') {
+            const name = node.childForFieldName('name');
+            if (name && name.type === 'identifier') bindingIn(scope, name.text).writes.push(fixed(OTHER));
+        } else if (type === 'assignment_expression' || type === 'augmented_assignment_expression') {
+            const left = node.childForFieldName('left');
+            const right = node.childForFieldName('right');
+            const plain = type === 'assignment_expression';
+            if (left && left.type === 'identifier') {
+                pending.push({
+                    name: left.text, scope,
+                    write: plain ? { kind: 'value', node: right, env: scope } : { kind: 'unknown' },
+                });
+            } else if (left && (left.type === 'member_expression' || left.type === 'subscript_expression')) {
+                // globalThis.it = ...: the global of that name is written.
+                const object = left.childForFieldName('object');
+                const property = left.childForFieldName('property') || left.childForFieldName('index');
+                if (object && object.type === 'identifier' && GLOBAL_OBJECTS.has(object.text)) {
+                    const name = !property ? null : property.type === 'string' ? literal(property)
+                        : left.type === 'member_expression' ? property.text : null;
+                    pending.push({ global: name, object: object.text, scope });
+                }
+            } else if (left) {
+                for (const name of patternNames(left)) {
+                    pending.push({ name, scope, write: { kind: 'unknown', node: right, env: scope } });
+                }
+            }
+        } else if (type === 'update_expression') {
+            const argument = node.childForFieldName('argument');
+            if (argument && argument.type === 'identifier') {
+                pending.push({ name: argument.text, scope, write: { kind: 'unknown' } });
+            }
+        } else if (type === 'call_expression') {
+            calls.push({ node, scope, fn });
+            const callee = node.childForFieldName('function');
+            if (callee && callee.type === 'identifier' && callee.text === 'eval') pending.push({ evalIn: varScope, scope });
+            // Object.assign(globalThis, ...), Object.defineProperty(global,
+            // 'it', ...): the globals they name are written; which ones,
+            // where the names are not written out, is not read. Any other
+            // call handed the global object is taken to leave the
+            // runner's functions alone.
+            const args = node.childForFieldName('arguments');
+            const values = (args && args.namedChildren) || [];
+            const target = values[0];
+            const method = callee && callee.type === 'member_expression' &&
+                /^(Object|Reflect)$/.test(callee.childForFieldName('object')?.text || '')
+                ? callee.childForFieldName('property')?.text : null;
+            if (method && target && target.type === 'identifier' && GLOBAL_OBJECTS.has(target.text)) {
+                const keysOf = object => object.namedChildren.map(member =>
+                    member.type === 'shorthand_property_identifier' ? member.text
+                        : member.type === 'pair' && member.childForFieldName('key')?.type !== 'computed_property_name'
+                            ? member.childForFieldName('key').text.replace(/^['"]|['"]$/g, '') : null);
+                let names = null;
+                if (method === 'defineProperty' || method === 'set') {
+                    names = [values[1] && values[1].type === 'string' ? literal(values[1]) : null];
+                } else if (method === 'assign' || method === 'defineProperties') {
+                    names = values.slice(1).flatMap(source => source.type === 'object' ? keysOf(source) : [null]);
+                }
+                for (const name of names || []) pending.push({ global: name, object: target.text, scope });
+            }
+        }
+        for (const child of node.namedChildren) build(child, scope, varScope, fn);
+    };
+
+    scopes.set(root.id, top);
+    for (const child of root.namedChildren) build(child, top, top, null);
+    for (const entry of pending) {
+        if (entry.write) {
+            const found = lookup(entry.scope, entry.name);
+            if (found && found.binding) found.binding.writes.push(entry.write);
+            else writtenGlobals.add(entry.name);
+        } else if (entry.evalIn) {
+            if (!lookup(entry.scope, 'eval')) entry.evalIn.dynamic = true;
+        } else if (!lookup(entry.scope, entry.object)) {
+            if (entry.global) writtenGlobals.add(entry.global);
+            else globalsHandedOver = true;
+        }
+    }
+
+    const requiredModule = (node, scope) => {
+        if (!node || node.type !== 'call_expression') return null;
+        const callee = node.childForFieldName('function');
+        if (!callee || callee.type !== 'identifier' || callee.text !== 'require' || lookup(scope, 'require')) return null;
+        const args = node.childForFieldName('arguments');
+        return args && args.namedChildren.length === 1 ? literal(args.namedChildren[0]) : null;
+    };
+    /** What a module gives: as a whole (name null) or under one name. */
+    const fromModule = (moduleName, name) => {
+        if (TEST_RUNNER_MODULES.has(moduleName)) {
+            if (name == null) {
+                return {
+                    namespace: true, runner: true,
+                    ...(TEST_CALLABLE_MODULES.has(moduleName) && { callable: 'test' }),
+                };
+            }
+            return isTestApiName(name) ? { api: name, runner: true } : OTHER;
+        }
+        if (name == null) return { namespace: true, module: moduleName };
+        const exported = helpers.exported ? helpers.exported(moduleName, name) : null;
+        if (exported) return exported;
+        // A module that is not read: a name spelled like the runner's
+        // function may be it, and may not.
+        return isTestApiName(name) ? UNREAD : OTHER;
+    };
+    const sameValue = (a, b) => !!a.other === !!b.other && !!a.unread === !!b.unread && a.api === b.api &&
+        !!a.namespace === !!b.namespace && a.module === b.module && !!a.runner === !!b.runner &&
+        a.callable === b.callable && a.calls === b.calls && !!a.global === !!b.global &&
+        (a.modifiers || []).join() === (b.modifiers || []).join();
+    const globalNamed = name => {
+        if (writtenGlobals.has(name) || globalsHandedOver) return UNREAD;
+        return { api: name };
+    };
+    const writeValue = (write, name) => {
+        switch (write.kind) {
+            case 'fixed': return write.value;
+            case 'parameter': return isTestApiName(name) ? UNREAD : OTHER;
+            case 'import': return fromModule(write.module, write.imported);
+            case 'value': return valueOf(write.node, write.env, name);
+            case 'member': {
+                const from = write.node ? resolve(write.node, write.env) : null;
+                if (from && from.namespace && from.module) return fromModule(from.module, write.key);
+                if (from && from.namespace && from.global) return isTestApiName(write.key) ? globalNamed(write.key) : OTHER;
+                if (from && from.namespace) return isTestApiName(write.key) ? { api: write.key, runner: from.runner } : OTHER;
+                if (!write.node || PLAIN_VALUES.has(write.node.type) || (from && (from.api || from.other))) return OTHER;
+                return isTestApiName(write.key) ? UNREAD : OTHER;
+            }
+            case 'maybe': {
+                // A function declared in a block may also be the name
+                // outside it: what that name held before decides.
+                const before = lookup(write.outer, name);
+                const held = before && before.binding ? valueOfBinding(before.binding) : null;
+                if (before && before.dynamic) return UNREAD;
+                if (held) return held.api || held.namespace || held.unread ? UNREAD : OTHER;
+                return isTestApiName(name) ? UNREAD : OTHER;
+            }
+            default:
+                // A value this does not follow (a loop's element, an
+                // update, a pattern): the runner's function only where
+                // the name or what it is taken from says so.
+                return isTestApiName(name) || (write.node && mentionsRunner(write.node, write.env)) ? UNREAD : OTHER;
+        }
+    };
+    const valueOfBinding = binding => {
+        if (binding.value !== undefined) return binding.value;
+        // A write that reads the name itself (x = x.trim()) says nothing
+        // by that: the other writes decide.
+        if (binding.resolving) return OTHER;
+        binding.resolving = true;
+        let value;
+        if (binding.writes.length === 0) {
+            // Declared and never written: undefined.
+            value = { other: true, calls: false };
+        } else {
+            const values = binding.writes.map(write => writeValue(write, binding.name));
+            value = values.every(each => sameValue(each, values[0])) ? values[0]
+                : values.some(each => each.unread || each.api || each.namespace) ? UNREAD : OTHER;
+        }
+        binding.resolving = false;
+        binding.value = value;
+        return value;
+    };
+    /** What an expression stands for, or null when it is none of the forms read. */
+    const resolve = (node, scope, depth = 0) => {
+        if (!node || depth > 8) return null;
+        if (WRAPPERS.has(node.type)) return resolve(node.namedChildren[0], scope, depth + 1);
+        if (node.type === 'identifier' || node.type === 'shorthand_property_identifier') {
+            const found = lookup(scope, node.text);
+            if (found && found.binding) return valueOfBinding(found.binding);
+            if (found && found.dynamic) return UNREAD;
+            if (GLOBAL_OBJECTS.has(node.text)) return { namespace: true, global: true };
+            return isTestApiName(node.text) ? globalNamed(node.text) : null;
+        }
+        if (node.type === 'call_expression') {
+            const name = requiredModule(node, scope);
+            return name == null ? null : fromModule(name, null);
+        }
+        if (node.type === 'member_expression') {
+            const object = resolve(node.childForFieldName('object'), scope, depth + 1);
+            const property = node.childForFieldName('property');
+            if (!object || !property || object.other) return null;
+            if (object.unread) return UNREAD;
+            if (object.api) {
+                if (isTestApiName(property.text)) return { ...object, api: property.text };
+                if (TEST_API_MODIFIERS.has(property.text)) {
+                    return { ...object, modifiers: [...(object.modifiers || []), property.text] };
+                }
+                return null;
+            }
+            if (object.namespace) {
+                if (object.module) return fromModule(object.module, property.text);
+                if (isTestApiName(property.text)) {
+                    return object.global ? globalNamed(property.text) : { api: property.text, runner: object.runner };
+                }
+                // The callable default of a runner module carries members too.
+                if (object.callable && TEST_API_MODIFIERS.has(property.text)) {
+                    return { api: object.callable, runner: object.runner, modifiers: [property.text] };
+                }
+            }
+        }
+        return null;
+    };
+    /** Does an expression name the runner's function or module anywhere? */
+    const mentionsRunner = (node, scope) => {
+        if (FUNCTION_NODES.has(node.type)) return false;
+        if (node.type === 'identifier' || node.type === 'call_expression' || node.type === 'member_expression') {
+            const value = resolve(node, scope);
+            if (value && (value.unread || (value.runner && (value.api || value.namespace)))) return true;
+        }
+        return node.namedChildren.some(child => mentionsRunner(child, scope));
+    };
+    /** A value an initializer stands for, or what an unreadable one leaves. */
+    const valueOf = (node, scope, name) => {
+        const resolved = resolve(node, scope);
+        if (resolved) return resolved;
+        if (!node) return { other: true, calls: false };
+        if (node.type !== 'class' && FUNCTION_NODES.has(node.type)) return { other: true, calls: true };
+        if (PLAIN_VALUES.has(node.type)) return { other: true, calls: false };
+        // A value made here is not the runner's function; one that holds
+        // the runner's names can hand them on.
+        if (BUILT_VALUES.has(node.type)) return mentionsRunner(node, scope) ? UNREAD : { other: true, calls: false };
+        return isTestApiName(name) || mentionsRunner(node, scope) ? UNREAD : OTHER;
+    };
+    /** Is the name a callee starts with one this cannot read? */
+    const unreadAt = (node, scope) => {
+        let base = node;
+        while (base && (base.type === 'member_expression' || base.type === 'call_expression' || WRAPPERS.has(base.type))) {
+            base = base.type === 'member_expression' ? base.childForFieldName('object')
+                : base.type === 'call_expression' ? base.childForFieldName('function') : base.namedChildren[0];
+        }
+        if (!base || base.type !== 'identifier') return false;
+        const value = resolve(base, scope);
+        return !!value && !!value.unread;
+    };
+    /**
+     * The modules the name a callee starts with is taken from (an import,
+     * a require, a member of one), or of a require called in place.
+     */
+    const modulesOf = (node, scope) => {
+        let base = node;
+        while (base && (base.type === 'member_expression' || WRAPPERS.has(base.type) ||
+            (base.type === 'call_expression' && requiredModule(base, scope) == null))) {
+            base = base.type === 'member_expression' ? base.childForFieldName('object')
+                : base.type === 'call_expression' ? base.childForFieldName('function') : base.namedChildren[0];
+        }
+        if (!base) return [];
+        if (base.type === 'call_expression') return [requiredModule(base, scope)];
+        if (base.type !== 'identifier') return [];
+        const found = lookup(scope, base.text);
+        const out = [];
+        for (const write of (found && found.binding ? found.binding.writes : [])) {
+            if (write.kind === 'import' && write.module != null) out.push(write.module);
+            else if ((write.kind === 'value' || write.kind === 'member') && write.node) {
+                const required = requiredModule(write.node, write.env);
+                if (required != null) out.push(required);
+            }
+        }
+        return out;
+    };
+    /**
+     * Is a callee a runner's setup hook: one of their names, bound by
+     * nothing in the file (the runner's global) or by an import from a
+     * runner's module.
+     */
+    const setupHookAt = (node, scope) => {
+        if (!node || node.type !== 'identifier' || !TEST_SETUP_HOOKS.has(node.text)) return false;
+        const found = lookup(scope, node.text);
+        if (found && found.dynamic) return true;
+        if (!found || !found.binding) return true;
+        const writes = found.binding.writes;
+        return writes.length > 0 && writes.every(write => {
+            if (write.kind === 'import') return TEST_RUNNER_MODULES.has(write.module);
+            if ((write.kind === 'value' || write.kind === 'member') && write.node) {
+                const required = requiredModule(write.node, write.env);
+                return required != null && TEST_RUNNER_MODULES.has(required);
+            }
+            return false;
+        });
+    };
+    return {
+        top, resolve, fromModule, unreadAt, calls, mentionsRunner, modulesOf, setupHookAt,
+        /** The record of a function node: `parent` is the function around it. */
+        functionOf: node => functions.get(node.id) || null,
+        /** What a name declared at the top of the file holds, or undefined. */
+        bound: name => top.names.has(name) ? valueOfBinding(top.names.get(name)) : undefined,
+        /** The one value a name is bound to where it is used ({ node, scope }), or null. */
+        valueAt: (node, scope) => {
+            if (!node || node.type !== 'identifier') return null;
+            const found = lookup(scope, node.text);
+            const writes = found && !found.dynamic && found.binding ? found.binding.writes : [];
+            return writes.length === 1 && writes[0].kind === 'value' && writes[0].node
+                ? { node: writes[0].node, scope: writes[0].env } : null;
+        },
+    };
+}
+
+/** The file's binder, built once for every question asked of the file. */
+function testBinderOf(helpers, tree) {
+    const cache = helpers.cache;
+    if (cache && cache.has('testBinder')) return cache.get('testBinder');
+    const binder = createTestBinder(helpers, tree.rootNode);
+    if (cache) cache.set('testBinder', binder);
+    return binder;
+}
+
+/** The declaring call a call node is, or null: { kind, table, rows, skip, todo, only, sometimes }. */
+function testApiCall(node, resolve) {
+    let callee = node.childForFieldName('function');
+    let table = false;
+    let rows = null;
+    let sometimes = false;
+    if (callee && callee.type === 'call_expression') {
+        // it.each(rows)(...), it.skipIf(cond)(...)
+        const inner = callee.childForFieldName('function');
+        if (!inner || inner.type !== 'member_expression') return null;
+        const property = inner.childForFieldName('property');
+        if (!property) return null;
+        if (TEST_API_TABLES.has(property.text)) {
+            table = true;
+            // The table: the call's argument, or the template it is tagged with.
+            const given = callee.childForFieldName('arguments');
+            rows = !given ? null : given.type === 'template_string' ? given : given.namedChildren[0] || null;
+        } else if (TEST_API_CONDITIONS.has(property.text)) sometimes = true;
+        else return null;
+        callee = inner.childForFieldName('object');
+    }
+    const resolved = resolve(callee);
+    if (!resolved) return null;
+    const api = resolved.api || (resolved.namespace && resolved.callable) || null;
+    if (!api) return null;
+    const modifiers = resolved.modifiers || [];
+    return {
+        kind: TEST_SUITE_APIS.has(api) ? 'suite' : 'test',
+        table, rows, sometimes,
+        skip: /^x/.test(api) || modifiers.includes('skip'),
+        todo: modifiers.includes('todo'),
+        only: modifiers.includes('only') || api === 'fit' || api === 'fdescribe',
+    };
+}
+
+/** The value of a title written as a literal, or null. */
+function literalTitle(node) {
+    if (!node) return null;
+    if (node.type !== 'string' && node.type !== 'template_string') return null;
+    if (node.namedChildren.some(child => child.type === 'template_substitution')) return null;
+    const body = node.text.slice(1, -1);
+    if (!body.includes('\\')) return body;
+    // Escapes that only quote a character; anything else is not read.
+    if (/\\(?!['"\x60\\])/.test(body)) return null;
+    return body.replace(/\\(['"\x60\\])/g, '$1');
+}
+
+/** Whether a literal is truthy: true, false, or null when it is no literal. */
+function literalTruth(node) {
+    if (!node) return null;
+    switch (node.type) {
+        case 'true': return true;
+        case 'false': case 'null': case 'undefined': return false;
+        case 'string': return node.text.length > 2;
+        case 'template_string':
+            return node.namedChildren.some(child => child.type === 'template_substitution') ? null : node.text.length > 2;
+        case 'number': {
+            const value = Number(node.text.replace(/_/g, '').replace(/n$/, ''));
+            return Number.isNaN(value) ? null : value !== 0;
+        }
+        case 'parenthesized_expression': return literalTruth(node.namedChildren[0]);
+        default: return null;
+    }
+}
+
+/**
+ * What an options object of a declaring call says: 'skip' (a skip or todo
+ * whose value is a truthy literal), 'sometimes' (one whose value is not a
+ * literal, a shorthand, a spread, a computed key that is not a string) or
+ * null (none, or a falsy literal: an empty reason does not skip).
+ */
+function declaredSkip(values, hasCallback) {
+    const options = values.find(value => value.type === 'object');
+    if (!options) return null;
+    let answer = null;
+    const weaker = () => {
+        if (answer !== 'skip') answer = 'sometimes';
+    };
+    for (const pair of options.namedChildren) {
+        if (pair.type === 'spread_element') {
+            weaker();
+            continue;
+        }
+        if (pair.type === 'shorthand_property_identifier') {
+            if (pair.text === 'skip' || (pair.text === 'todo' && !hasCallback)) weaker();
+            continue;
+        }
+        if (pair.type !== 'pair') continue;
+        const key = pair.childForFieldName('key');
+        const value = pair.childForFieldName('value');
+        if (!key || !value) continue;
+        let name;
+        if (key.type === 'computed_property_name') {
+            const inner = key.namedChildren[0];
+            if (!inner || inner.type !== 'string') {
+                weaker();
+                continue;
+            }
+            name = inner.text.slice(1, -1);
+        } else {
+            name = key.text.replace(/^['"]|['"]$/g, '');
+        }
+        if (name !== 'skip' && name !== 'todo') continue;
+        // A todo with a body still runs it.
+        if (name === 'todo' && hasCallback) continue;
+        const truth = literalTruth(value);
+        if (truth === true) answer = 'skip';
+        else if (truth == null) weaker();
+    }
+    return answer;
+}
+
+/**
+ * The tests a JavaScript or TypeScript file declares: calls of the
+ * runners' declaring functions, found by what the callee is bound to at
+ * the call (see createTestBinder), named by their literal titles and by
+ * the suites whose callbacks hold them. A title that is not a literal, a
+ * table of cases and a declaration inside a function that is not a
+ * suite's callback are tests whose runtime names are not the written
+ * ones; the last exist only where that function is called.
+ *
+ * The body of a test is whatever is passed for it: a function written in
+ * place, or any other expression (a named function, a member, the result
+ * of a call), which is taken to be a function unless the name is bound in
+ * the file to something that is none. A test given no body at all has
+ * nothing to execute. A test marked skip (or inside a skipped suite) is
+ * declared and not executed; options that are not written out as an
+ * object in the call may skip it. "only" is the mark as written; "parent"
+ * is the index of the suite a unit stands in (-1: the file), so each
+ * runner's own rule for focus can be applied. "open" says the file calls
+ * through a name that may be the runner's function and is not read, or
+ * hands the runner's function to something: it holds tests this did not
+ * see. "calledModules" are the modules whose functions the file calls
+ * outside a test: one that declares tests when called gives them to
+ * this file ("calledWhenCalled": from inside a function of the file, so
+ * to whoever calls that function).
+ *
+ * A declaration exists as often as the statement that makes it runs, up
+ * to the function that holds it: in a branch, a handler or after a
+ * statement that may leave (a return, a throw) it runs only sometimes; in
+ * a loop it stands for several tests, and for none when the loop does not
+ * run. A table of cases is read where it is written out, here or in the
+ * one value its name is bound to: an empty one declares nothing (jest
+ * refuses the file: "emptyTable"), one that is not written out may be
+ * empty.
+ */
+function testUnits(fileEntry, helpers) {
+    const tree = helpers.tree();
+    if (!tree) return null;
+    const binder = testBinderOf(helpers, tree);
+    const units = [];
+    // ---- where a declaration stands in the flow of its function ----
+    const CLASS_NODES = new Set(['class_declaration', 'class', 'class_body', 'abstract_class_declaration']);
+    // Can running a statement leave the function it stands in: a return,
+    // a throw that no handler around it catches, process.exit.
+    const leaves = (node, caught = false) => {
+        if (FUNCTION_NODES.has(node.type) || CLASS_NODES.has(node.type)) return false;
+        if (node.type === 'return_statement') return true;
+        if (node.type === 'throw_statement') return !caught;
+        if (node.type === 'call_expression') {
+            const callee = node.childForFieldName('function');
+            if (callee && callee.type === 'member_expression' && callee.childForFieldName('object')?.text === 'process' &&
+                callee.childForFieldName('property')?.text === 'exit') return true;
+        }
+        if (node.type === 'try_statement') {
+            const handled = !!node.childForFieldName('handler');
+            return node.namedChildren.some(child => leaves(child,
+                caught || (handled && sameNode(child, node.childForFieldName('body')))));
+        }
+        return node.namedChildren.some(child => leaves(child, caught));
+    };
+    const leaveMemo = new Map(); // id of a block -> where its first statement that may leave it ends
+    const leavesBefore = (block, statement) => {
+        if (!leaveMemo.has(block.id)) {
+            const first = block.namedChildren.find(statement => leaves(statement));
+            leaveMemo.set(block.id, first ? first.endIndex : Infinity);
+        }
+        return statement.startIndex >= leaveMemo.get(block.id);
+    };
+    const flowMemo = new Map();
+    /**
+     * What the statements around a call say, up to the function or the
+     * file that holds it: it runs only `sometimes`, or as often as a loop
+     * does (`several`).
+     */
+    const flowOf = (node, scope) => {
+        if (flowMemo.has(node.id)) return flowMemo.get(node.id);
+        let sometimes = false;
+        let several = false;
+        for (let child = node, parent = node.parent; parent; child = parent, parent = parent.parent) {
+            if (FUNCTION_NODES.has(parent.type) || CLASS_NODES.has(parent.type)) break;
+            const is = field => sameNode(parent.childForFieldName(field), child);
+            switch (parent.type) {
+                case 'if_statement': case 'ternary_expression':
+                    if (!is('condition')) sometimes = true;
+                    break;
+                case 'binary_expression':
+                    if (is('right') && /^(&&|\|\||\?\?)$/.test(parent.childForFieldName('operator')?.text || '')) sometimes = true;
+                    break;
+                case 'switch_case':
+                    if (!is('value')) sometimes = true;
+                    break;
+                case 'switch_default': case 'catch_clause':
+                    sometimes = true;
+                    break;
+                case 'for_statement':
+                    if (!is('initializer')) several = sometimes = true;
+                    break;
+                case 'for_in_statement':
+                    if (is('body')) {
+                        several = true;
+                        // Over a list written out that holds something, the body runs.
+                        if (!parent.children.some(part => part.type === 'of') ||
+                            tableRows(parent.childForFieldName('right'), scope) !== 'rows') sometimes = true;
+                    }
+                    break;
+                case 'while_statement':
+                    several = sometimes = true;
+                    break;
+                case 'do_statement':
+                    // The body runs once at least.
+                    several = true;
+                    break;
+                case 'statement_block': case 'program':
+                    if (leavesBefore(parent, child)) sometimes = true;
+                    break;
+                default: break;
+            }
+        }
+        const answer = { sometimes, several };
+        flowMemo.set(node.id, answer);
+        return answer;
+    };
+    /** What a table of cases holds: 'rows', 'empty', or 'unread'. */
+    const tableRows = (node, scope, depth = 0) => {
+        if (!node || depth > 4) return 'unread';
+        switch (node.type) {
+            // A table written as a template has a heading and rows.
+            case 'template_string': return 'rows';
+            case 'parenthesized_expression': case 'as_expression': case 'satisfies_expression': case 'non_null_expression':
+                return tableRows(node.namedChildren[0], scope, depth + 1);
+            case 'array': {
+                const items = node.namedChildren.filter(item => item.type !== 'comment');
+                if (items.length === 0) return 'empty';
+                if (items.some(item => item.type !== 'spread_element')) return 'rows';
+                const parts = items.map(item => tableRows(item.namedChildren[0], scope, depth + 1));
+                return parts.includes('rows') ? 'rows' : parts.every(part => part === 'empty') ? 'empty' : 'unread';
+            }
+            case 'identifier': {
+                const held = binder.valueAt(node, scope);
+                return held ? tableRows(held.node, held.scope, depth + 1) : 'unread';
+            }
+            default: return 'unread';
+        }
+    };
+    let emptyTable = false;
+    // A call through a name that may be the runner's function and is not
+    // read: a test this does not see.
+    let unreadCall = false;
+    let handedOver = false;
+    const calledModules = new Set();
+    const calledWhenCalled = new Set();
+    const stoppedSuites = new Set(); // indexes of suites (-1: the file) a setup hook can skip
+    /** Is a callee written the way a runner's declaring function is called? */
+    const declaringShape = node => {
+        if (!node) return false;
+        if (node.type === 'identifier') return true;
+        if (node.type === 'call_expression') return declaringShape(node.childForFieldName('function'));
+        if (node.type !== 'member_expression') return false;
+        const property = node.childForFieldName('property')?.text || '';
+        return (isTestApiName(property) || TEST_API_MODIFIERS.has(property) || TEST_API_TABLES.has(property) ||
+            TEST_API_CONDITIONS.has(property)) && declaringShape(node.childForFieldName('object'));
+    };
+    /** What an argument after the title is: a body, options, or neither. */
+    const argumentKind = (value, scope) => {
+        if (FUNCTION_NODES.has(value.type)) return 'function';
+        if (value.type === 'object') return 'options';
+        if (PLAIN_VALUES.has(value.type) || value.type === 'array') return 'value';
+        if (value.type === 'spread_element') return 'expression';
+        const held = binder.resolve(value, scope);
+        if (held && held.other && held.calls === false) return 'held';
+        return 'expression';
+    };
+    // Where a call stands: under the suites whose callbacks hold it, inside
+    // a test, or inside a function that is no declaring call's callback
+    // (then what it declares exists only where that function is called).
+    const TOP = { suites: [], inTest: false, indirect: false };
+    const owners = new Map(); // function record -> the declaring call whose callback it is
+    const contexts = new Map();
+    const contextOf = fn => {
+        if (!fn) return TOP;
+        if (!contexts.has(fn)) {
+            const owner = owners.get(fn);
+            contexts.set(fn, owner
+                ? {
+                    suites: owner.suite ? [...owner.context.suites, owner.suite] : owner.context.suites,
+                    inTest: owner.context.inTest || owner.kind === 'test',
+                    indirect: owner.context.indirect,
+                }
+                : { ...contextOf(fn.parent), indirect: true });
+        }
+        return contexts.get(fn);
+    };
+    for (const call of binder.calls) {
+        const node = call.node;
+        const api = testApiCall(node, callee => binder.resolve(callee, call.scope));
+        if (!api) {
+            const callee = node.childForFieldName('function');
+            const where = contextOf(call.fn);
+            // Inside a test nothing declares a test of the file: what a
+            // runner takes there is a part of that test.
+            if (where.inTest) continue;
+            // A declaration is given a title or a body, and is called as
+            // the runners' functions are (the name, a member that is one
+            // of their names or marks): any other call through a name
+            // that is not read declares nothing.
+            if ((node.childForFieldName('arguments')?.namedChildCount || 0) > 0 && declaringShape(callee) &&
+                binder.unreadAt(callee, call.scope)) unreadCall = true;
+            // A setup hook that can skip (mocha's this.skip(), a skip of
+            // the context a runner hands it), or whose body is not
+            // written here: the tests of its suite run only sometimes.
+            if (binder.setupHookAt(callee, call.scope)) {
+                const given = (node.childForFieldName('arguments')?.namedChildren || []);
+                const bodies = given.filter(value => FUNCTION_NODES.has(value.type));
+                const unwritten = given.some(value => !FUNCTION_NODES.has(value.type) && !PLAIN_VALUES.has(value.type) &&
+                    value.type !== 'object');
+                const skips = part => ((part.type === 'property_identifier' || part.type === 'identifier' ||
+                    part.type === 'shorthand_property_identifier_pattern') && part.text === 'skip') || part.namedChildren.some(skips);
+                if (unwritten || bodies.some(skips)) {
+                    const around = where.suites;
+                    stoppedSuites.add(around.length > 0 ? around[around.length - 1].index : -1);
+                }
+                continue;
+            }
+            // The runner's function handed to something (an argument, a
+            // list it is called through, call and apply): what declares
+            // with it there is not seen.
+            const handed = [node.childForFieldName('arguments'),
+                callee && callee.type === 'member_expression' ? callee.childForFieldName('object') : null];
+            if (handed.some(part => part && part.type !== 'identifier' && binder.mentionsRunner(part, call.scope)) ||
+                (callee && callee.type === 'member_expression' && callee.childForFieldName('object').type === 'identifier' &&
+                    /^(call|apply|bind)$/.test(callee.childForFieldName('property')?.text || '') &&
+                    binder.mentionsRunner(callee.childForFieldName('object'), call.scope))) handedOver = true;
+            // A function of another module called outside a test: tests
+            // it declares when called are tests of this file, or, from a
+            // function of this file, of whoever calls that.
+            if (callee) {
+                for (const name of binder.modulesOf(callee, call.scope)) (where.indirect ? calledWhenCalled : calledModules).add(name);
+            }
+            continue;
+        }
+        const ctx = contextOf(call.fn);
+        const args = node.childForFieldName('arguments');
+        const values = args ? args.namedChildren : [];
+        const title = literalTitle(values[0]);
+        // The first argument is the title, unless a body, options
+        // or a spread stands there (node: test(fn), test(options, fn)).
+        const rest = values[0] && (FUNCTION_NODES.has(values[0].type) || values[0].type === 'object' ||
+            values[0].type === 'spread_element') ? values : values.slice(1);
+        const kinds = rest.map(value => argumentKind(value, call.scope));
+        const callback = rest.filter((value, i) => kinds[i] === 'function').pop() || null;
+        const given = kinds.filter(kind => kind === 'expression').length;
+        const hasBody = !!callback || given > 0;
+        const dynamic = title == null ? 'name-not-literal'
+            : api.table ? 'generated-cases'
+            : ctx.indirect || ctx.inTest ? 'declared-indirectly' : null;
+        const flow = flowOf(node, call.scope);
+        const rows = api.table ? tableRows(api.rows, call.scope) : 'rows';
+        if (rows === 'empty') emptyTable = true;
+        const option = declaredSkip(rest, hasBody);
+        // Options that are not written out here: a name bound to
+        // something that is no function, or an expression beside
+        // the one that is the body.
+        const optionsUnread = hasBody && (kinds.includes('held') || given > (callback ? 0 : 1));
+        // A test with no body has nothing to execute (pending, todo).
+        const skipped = api.skip || (api.kind === 'test' && !hasBody) || option === 'skip' || rows === 'empty' ||
+            ctx.suites.some(suite => suite.skipped);
+        const sometimes = api.sometimes || option === 'sometimes' || (optionsUnread && !skipped) ||
+            flow.sometimes || rows === 'unread' ||
+            ctx.indirect || ctx.inTest || ctx.suites.some(suite => suite.sometimes);
+        const several = flow.several || ctx.suites.some(suite => suite.several);
+        const index = units.length;
+        const outer = ctx.suites[ctx.suites.length - 1];
+        units.push({
+            kind: api.kind, name: title, titled: true, suite: ctx.suites.map(suite => suite.name),
+            line: node.startPosition.row + 1, startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            parent: outer ? outer.index : -1,
+            ...(api.only && { only: true }),
+            ...(skipped && { skipped: true }),
+            ...(sometimes && { conditional: true }),
+            ...((dynamic || ctx.suites.some(suite => suite.dynamic)) && {
+                dynamic: dynamic || 'suite-name-not-literal',
+            }),
+            // Declared by a statement that runs more than once.
+            ...(several && { several: true }),
+            // Declared where a function of the file is called, by whoever calls it.
+            ...(ctx.indirect && { indirect: true }),
+        });
+        // The callback's body is where the suite's own declarations
+        // are written, not a function apart.
+        const held = callback ? binder.functionOf(callback) : null;
+        if (held) {
+            owners.set(held, {
+                context: ctx, kind: api.kind,
+                suite: api.kind === 'suite'
+                    ? { name: title == null ? '' : title, dynamic: !!dynamic, skipped, sometimes, several, index } : null,
+            });
+        }
+    }
+    // A hook of a suite holds for every test in it, however deep.
+    if (stoppedSuites.size > 0) {
+        for (const unit of units) {
+            if (unit.kind !== 'test' || unit.conditional) continue;
+            for (let at = unit.parent; ; at = units[at].parent) {
+                if (stoppedSuites.has(at)) {
+                    unit.conditional = true;
+                    break;
+                }
+                if (at === -1) break;
+            }
+        }
+    }
+    return {
+        units,
+        open: unreadCall || handedOver,
+        ...(emptyTable && { emptyTable: true }),
+        ...(calledModules.size > 0 && { calledModules: [...calledModules].sort() }),
+        ...(calledWhenCalled.size > 0 && { calledWhenCalled: [...calledWhenCalled].sort() }),
+        ...(units.some(unit => unit.only) && { focus: true }),
+    };
+}
+
+/**
+ * What a module exports under a name, as far as declaring tests goes: the
+ * runner's function ({ api }), a namespace of it, something else
+ * ({ other }), or null when no export of that name is read here.
+ */
+function testExport(fileEntry, helpers, name) {
+    const tree = helpers.tree();
+    if (!tree) return null;
+    const binder = testBinderOf(helpers, tree);
+    const top = binder.top;
+    const settle = value => value && !value.unread ? value : null;
+    const valueOf = node => {
+        const resolved = binder.resolve(node, top);
+        if (resolved) return resolved;
+        return node && (PLAIN_VALUES.has(node.type) || BUILT_VALUES.has(node.type) || FUNCTION_NODES.has(node.type))
+            ? OTHER : null;
+    };
+    const literal = node => node && node.type === 'string' ? node.text.slice(1, -1) : null;
+    let found = null;
+    for (const statement of tree.rootNode.namedChildren) {
+        if (statement.type === 'expression_statement') {
+            // module.exports = ..., module.exports.x = ..., exports.x = ...
+            const assignment = statement.namedChildren[0];
+            if (!assignment || assignment.type !== 'assignment_expression') continue;
+            const left = assignment.childForFieldName('left');
+            const right = assignment.childForFieldName('right');
+            if (!left || !right) continue;
+            const target = left.text.replace(/\s+/g, '');
+            if (target === 'module.exports' || target === 'exports') {
+                if (right.type === 'object') {
+                    for (const property of right.namedChildren) {
+                        if (property.type === 'shorthand_property_identifier' && property.text === name) {
+                            found = valueOf(property);
+                        } else if (property.type === 'pair') {
+                            const key = property.childForFieldName('key');
+                            if (key && key.text.replace(/^['"]|['"]$/g, '') === name) {
+                                found = valueOf(property.childForFieldName('value'));
+                            }
+                        }
+                    }
+                } else {
+                    const whole = binder.resolve(right, top);
+                    if (whole && whole.namespace) {
+                        found = whole.module ? binder.fromModule(whole.module, name)
+                            : isTestApiName(name) ? { api: name, runner: whole.runner } : OTHER;
+                    } else if (whole && whole.api && name === 'default') {
+                        found = whole;
+                    }
+                }
+            } else if (target === `module.exports.${name}` || target === `exports.${name}`) {
+                found = valueOf(right);
+            }
+            continue;
+        }
+        if (statement.type !== 'export_statement') continue;
+        const source = literal(statement.childForFieldName('source'));
+        const clause = statement.namedChildren.find(child => child.type === 'export_clause');
+        if (clause) {
+            for (const spec of clause.namedChildren) {
+                const local = spec.childForFieldName('name');
+                const alias = spec.childForFieldName('alias');
+                if (!local || (alias || local).text !== name) continue;
+                found = source != null ? binder.fromModule(source, local.text)
+                    : (binder.bound(local.text) || valueOf(local));
+            }
+        } else if (source != null && statement.children.some(child => child.type === '*')) {
+            // export * from 'm': the name is whatever that module gives.
+            const given = binder.fromModule(source, name);
+            if (given && !given.other && !given.unread) found = given;
+        } else {
+            const declared = binder.bound(name);
+            const declares = statement.namedChildren.some(child => DECLARING.has(child.type));
+            if (declares && declared) found = declared;
+        }
+    }
+    return settle(found);
+}
+
 /**
  * Classify a JS/TS symbol as a runtime entry point of a specific kind.
  * Returns 'framework' | null.
@@ -5889,7 +7050,301 @@ function isEntryPoint(symbol) {
     return getEntryPointKind(symbol) !== null;
 }
 
+const CLASS_DECLARATION_NODES = new Set(['class_declaration', 'abstract_class_declaration', 'class']);
+
+const isStaticMember = member => member.children.some(part => part.type === 'static');
+const isHiddenMember = node => node.namedChildren.some(part =>
+    part.type === 'accessibility_modifier' && part.text !== 'public');
+
+/**
+ * Does this class itself declare a private or protected INSTANCE member?
+ * TypeScript then holds its values to that declaration: only its own
+ * instances and those of its descendants are assignable to it. Without
+ * one, anything with the class's members is a value of it: an object
+ * literal, another class, and where a private member is inherited, any
+ * class that inherits the same one. A static member belongs to the
+ * constructor, a constructor parameter with a modifier is a member, and
+ * the constructor's own modifier says who may call it, not what a value
+ * has.
+ *
+ * @param {Set<number>} [ignoredLines] members that start on these lines
+ *   are not counted: the class as it was before a change that added them
+ */
+function classHasNominalMember(classNode, ignoredLines = null) {
+    const body = classNode && classNode.childForFieldName('body');
+    if (!body) return false;
+    const ignored = node => !!ignoredLines && ignoredLines.has(node.startPosition.row + 1);
+    for (const member of body.namedChildren) {
+        if (ignored(member) || isStaticMember(member)) continue;
+        const name = member.childForFieldName('name');
+        if (name && name.text === 'constructor') {
+            const parameters = member.childForFieldName('parameters');
+            for (const parameter of parameters ? parameters.namedChildren : []) {
+                if (!ignored(parameter) && isHiddenMember(parameter)) return true;
+            }
+            continue;
+        }
+        if (isHiddenMember(member) || (name && name.type === 'private_property_identifier')) return true;
+    }
+    return false;
+}
+
+/**
+ * How the member `name` of a class, declared on `line`, takes part in the
+ * class's type: `role` is 'instance' (a member of every value), 'optional'
+ * (`m?(): T`) or 'static' (a member of the constructor); `hidden` is true
+ * for a private, protected or `#` member, which no other code can name or
+ * enumerate. null when the class body has no such member.
+ */
+function classMemberRole(classNode, name, line) {
+    const body = classNode && classNode.childForFieldName('body');
+    for (const member of body ? body.namedChildren : []) {
+        const nameNode = member.childForFieldName('name');
+        if (!nameNode || nameNode.text !== name) continue;
+        if (line < member.startPosition.row + 1 || line > member.endPosition.row + 1) continue;
+        const hidden = isHiddenMember(member) || nameNode.type === 'private_property_identifier';
+        if (isStaticMember(member)) return { role: 'static', hidden };
+        return { role: member.children.some(part => part.type === '?') ? 'optional' : 'instance', hidden };
+    }
+    return null;
+}
+
+// The comments the TypeScript scanner reads as directives. A directive
+// starts its comment (`// @ts-ignore`, `/* @ts-ignore */`, the last line
+// of a block comment) and is matched as a prefix (`@ts-ignored` is one);
+// `@ts-nocheck` is a pragma of a `//` comment.
+const TS_DIRECTIVE_LINE = /^\/\/\/?\s*@(?:ts-expect-error|ts-ignore)/;
+const TS_DIRECTIVE_BLOCK = /^(?:\/|\*)*\s*@(?:ts-expect-error|ts-ignore)/;
+// A file pragma: `// @name`, the name ending at a space or a colon.
+const TS_FILE_PRAGMA = /^\/\/\/?\s*@([^\s:]+)/;
+
+/** Lines that hold a directive comment, and whether the file is unchecked. */
+function checkDirectives(root) {
+    const lines = new Set();
+    let unchecked = false;
+    for (const comment of root.descendantsOfType('comment')) {
+        const text = comment.text;
+        const directive = text.startsWith('//') ? TS_DIRECTIVE_LINE.test(text)
+            : TS_DIRECTIVE_BLOCK.test(text.slice(text.lastIndexOf('\n') + 1).trimStart());
+        if (directive) lines.add(comment.endPosition.row + 1);
+    }
+    // `@ts-nocheck` and `@ts-check` are pragmas of the `//` comments
+    // before the first token, read without regard to case: the last of
+    // either decides.
+    for (const first of root.children) {
+        if (first.type === 'hash_bang_line') continue;
+        if (first.type !== 'comment') break;
+        const pragma = first.text.startsWith('//') ? TS_FILE_PRAGMA.exec(first.text) : null;
+        const name = pragma ? pragma[1].toLowerCase() : null;
+        if (name === 'ts-nocheck') unchecked = true;
+        else if (name === 'ts-check') unchecked = false;
+    }
+    return { lines, unchecked };
+}
+
+/**
+ * The line the compiler reports a break on: the token it underlines.
+ *   arity        the callee's name (the property of a member call), or the
+ *                first argument too many;
+ *   import-name  the imported name; import-module: the module string;
+ *   literal      the declared name of the variable the literal is assigned to.
+ * `site.line` is where the engine saw the site; the two differ when a
+ * statement runs over several lines. The call is the one the engine
+ * measured (`site.span`: its source range), whatever name it is called
+ * under and however many calls share its line; an import is the statement
+ * that names `site.module`.
+ */
+function reportedLine(root, site) {
+    const line = site.line;
+    const range = [{ row: line - 1, column: 0 }, { row: line, column: 0 }];
+    const spans = node => node.startPosition.row + 1 <= line && node.endPosition.row + 1 >= line;
+    if (site.kind === 'arity') {
+        const calls = site.span ? [nodeAtSpan(root, site.span, CALL_SHAPES)].filter(Boolean)
+            : root.descendantsOfType([...CALL_SHAPES], ...range).filter(call => {
+                const callee = call.childForFieldName(call.type === 'new_expression' ? 'constructor' : 'function');
+                const named = callee && (callee.childForFieldName('property') || callee);
+                return !!named && named.startPosition.row + 1 === line &&
+                    (call.type === 'new_expression' || !site.name || named.text === site.name);
+            });
+        for (const call of calls) {
+            const callee = call.childForFieldName(call.type === 'new_expression' ? 'constructor' : 'function');
+            const named = callee && (callee.childForFieldName('property') || callee);
+            if (!named) continue;
+            const given = (call.childForFieldName('arguments')?.namedChildren || [])
+                .filter(argument => argument.type !== 'comment');
+            // `f.apply(self, [..])` is reported at the list; `f.call(self,
+            // ..)` passes its arguments one slot later.
+            if (site.indirect === 'apply' && given[1]) return given[1].startPosition.row + 1;
+            const first = site.indirect === 'call' ? 1 : 0;
+            if (Number.isInteger(site.most) && given.length - first > site.most) {
+                return given[site.most + first].startPosition.row + 1;
+            }
+            return (call.type === 'new_expression' ? call : named).startPosition.row + 1;
+        }
+        return line;
+    }
+    if (site.kind === 'import-name' || site.kind === 'import-module') {
+        const quoted = node => (node ? node.text.slice(1, -1) : null);
+        const statements = root.descendantsOfType(['import_statement', 'export_statement'], ...range).filter(spans);
+        const naming = site.module === undefined ? statements
+            : statements.filter(statement => quoted(statement.childForFieldName('source')) === site.module);
+        for (const statement of naming.length > 0 ? naming : statements) {
+            if (site.kind === 'import-name') {
+                const clause = statement.descendantsOfType('import_clause')[0];
+                const named = site.name === 'default' ? (clause ? clause.namedChildren[0] : null)
+                    : statement.descendantsOfType(['identifier', 'property_identifier', 'type_identifier'])
+                        .find(node => node.text === site.name);
+                if (named) return named.startPosition.row + 1;
+            }
+            const source = statement.childForFieldName('source');
+            if (source) return source.startPosition.row + 1;
+        }
+        const written = root.descendantsOfType('string', ...range).find(node => node.startPosition.row + 1 >= line);
+        return written ? written.startPosition.row + 1 : line;
+    }
+    if (site.kind === 'literal') {
+        for (const declarator of root.descendantsOfType('variable_declarator', ...range)) {
+            const value = declarator.childForFieldName('value');
+            if (value && value.startPosition.row + 1 === line) {
+                return (declarator.childForFieldName('name') || declarator).startPosition.row + 1;
+            }
+        }
+    }
+    return line;
+}
+
+/**
+ * Has the type checker been told not to report this break? As its own
+ * scanner decides: the file carries `@ts-nocheck`, or walking up from the
+ * line the break is reported on, through blank lines and `//` comments
+ * only, there is a line that holds a directive comment.
+ *
+ * @param {object} site - { lines, root, line, kind, name, most, memo }:
+ *   `memo` is a Map kept per file for one operation
+ */
+function checkSuppressedAt(site) {
+    const { lines, root, memo } = site;
+    if (!root) return false;
+    if (memo && !memo.has('directives')) memo.set('directives', checkDirectives(root));
+    const directives = memo ? memo.get('directives') : checkDirectives(root);
+    if (directives.unchecked) return true;
+    for (let above = reportedLine(root, site) - 1; above >= 1; above--) {
+        if (directives.lines.has(above)) return true;
+        const text = String(lines[above - 1] === undefined ? '' : lines[above - 1]).trim();
+        if (text !== '' && !/^\/\/.*$/.test(text)) return false;
+    }
+    return false;
+}
+
+const inTryBlock = node => {
+    for (let up = node.parent; up; up = up.parent) {
+        if (up.type === 'try_statement') return true;
+        if (FUNCTION_SCOPE_NODES.has(up.type)) return false;
+    }
+    return false;
+};
+/**
+ * Is the import written on `line` one whose module must be there for the
+ * project to pass its own judge?
+ *   typed (TypeScript): an import or export-from statement, `import x =
+ *     require(..)`, or `import(..)`: the compiler resolves each of them,
+ *     wherever it is written. A `require(..)` call is a call to it.
+ *   untyped (JavaScript): the runtime is the judge. The same statements,
+ *     and a `require(..)` or `import(..)` call that is not inside a `try`
+ *     block, where a missing module is what the block is for.
+ * Several imports can share a line: the one asked about is the one that
+ * names `module`, as it is written.
+ */
+function checkedImportAt(root, line, typed, module) {
+    const range = [{ row: line - 1, column: 0 }, { row: line, column: 0 }];
+    const on = node => node.startPosition.row + 1 <= line && node.endPosition.row + 1 >= line;
+    const names = written => module === undefined || (!!written && written.text.slice(1, -1) === module);
+    if (root.descendantsOfType('import_statement', ...range).some(node => on(node) &&
+        names(node.childForFieldName('source') || node.descendantsOfType('string')[0]))) return true;
+    if (root.descendantsOfType('export_statement', ...range)
+        .some(node => on(node) && node.childForFieldName('source') && names(node.childForFieldName('source')))) return true;
+    for (const call of root.descendantsOfType('call_expression', ...range)) {
+        if (!on(call)) continue;
+        const callee = call.childForFieldName('function');
+        if (!callee || !names(call.childForFieldName('arguments')?.namedChildren[0])) continue;
+        if (callee.type === 'import') {
+            if (typed || !inTryBlock(call)) return true;
+        } else if (!typed && callee.type === 'identifier' && callee.text === 'require' && !inTryBlock(call)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+const CALL_SHAPES = new Set(['call_expression', 'new_expression']);
+
+/** The node of one of `types` that covers exactly `span`, or null. */
+function nodeAtSpan(root, span, types) {
+    for (let node = root.descendantForIndex(span.start, Math.max(span.start, span.end - 1)); node; node = node.parent) {
+        if (node.startIndex === span.start && node.endIndex === span.end && types.has(node.type)) return node;
+        if (node.startIndex < span.start || node.endIndex > span.end) break;
+    }
+    return null;
+}
+
+// Members every object has (the `Object` interface): a literal that does
+// not write `toString` still has one.
+const OBJECT_MEMBERS = ['constructor', 'toString', 'toLocaleString', 'valueOf', 'hasOwnProperty',
+    'isPrototypeOf', 'propertyIsEnumerable'];
+
+/**
+ * The name a literal's key gives its member, or null when it cannot be
+ * read off the token: an escape (`"brand"`, `brand`) or a
+ * number (`0x1` is the key "1") spells a name the text is not.
+ */
+function literalKeyName(key) {
+    if (key.text.includes('\\')) return null;
+    if (key.type === 'property_identifier' || key.type === 'shorthand_property_identifier') return key.text;
+    if (key.type === 'string') return key.text.slice(1, -1);
+    return null;
+}
+
+/**
+ * Members of the object literal that starts on `line` and is the whole
+ * value of a declaration with a type annotation (`const box: Box = {..}`),
+ * with the members every object has. `open`: what the literal has cannot
+ * be read: a spread, a computed, escaped or numeric key; a literal that is
+ * not the declared value itself (an assertion or a call around it decides
+ * its type).
+ * @returns {{names: Set<string>, open: boolean}|null} null: no object
+ *   literal starts on that line
+ */
+function typedLiteralMembers(root, line) {
+    const objects = root.descendantsOfType('object', { row: line - 1, column: 0 }, { row: line, column: 0 })
+        .filter(node => node.startPosition.row + 1 === line);
+    if (objects.length === 0) return null;
+    const declared = objects.filter(node => {
+        const holder = node.parent;
+        return holder && holder.type === 'variable_declarator' && holder.childForFieldName('type') &&
+            holder.childForFieldName('value')?.id === node.id;
+    });
+    const names = new Set(OBJECT_MEMBERS);
+    if (declared.length !== 1) return { names, open: true };
+    let open = false;
+    for (const member of declared[0].namedChildren) {
+        if (member.type === 'comment') continue;
+        const key = member.type === 'pair' ? member.childForFieldName('key')
+            : member.type === 'method_definition' ? member.childForFieldName('name')
+                : member.type === 'shorthand_property_identifier' ? member : null;
+        const name = key ? literalKeyName(key) : null;
+        if (name !== null) names.add(name);
+        else open = true;
+    }
+    return { names, open };
+}
+
 module.exports = {
+    classHasNominalMember,
+    classMemberRole,
+    typedLiteralMembers,
+    checkSuppressedAt,
+    checkedImportAt,
+    CLASS_DECLARATION_NODES,
     findFunctions,
     findClasses,
     findStateObjects,
@@ -5901,5 +7356,8 @@ module.exports = {
     findUsagesInCode,
     isEntryPoint,
     getEntryPointKind,
+    testUnits,
+    testExport,
+    TEST_RUNNER_MODULES,
     parse
 };