ucn 5.5.3 → 5.6.1

package/languages/python.js

@@ -342,6 +342,8 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 ...(paramTypes && { paramTypes }),
                 ...(docstring && { docstring }),
                 ...(decorators.length > 0 && { decorators }),
+                ...(decorators.length > 0 && { registrationUnknown: require('../core/python-binding-identity').registrationUnknown(node) }),
+                runtimeOwnerPath: require('../core/python-binding-identity').pythonRuntimeOwners(node),
                 ...(isOverloadDecorated(decorators) && { isSignature: true }),
                 ...(nameLine !== decoratorStartLine && { nameLine })
             });
@@ -389,7 +391,11 @@ function _processClass(node, classes, processedRanges, lines) {
             members,
             ...(docstring && { docstring }),
             ...(decorators.length > 0 && { decorators }),
+            ...(decorators.length > 0 && { registrationUnknown: require('../core/python-binding-identity').registrationUnknown(node) }),
+            runtimeOwnerPath: require('../core/python-binding-identity').pythonRuntimeOwners(node),
             ...(bases.length > 0 && { extends: bases.join(', ') }),
+            // A protocol class is satisfied by shape: no class has to name it.
+            ...(isProtocolClass(node) && { protocolClass: true }),
             ...(nameLine !== startLine && { nameLine }),
             ...lexicalScope,
         });
@@ -987,6 +993,51 @@ function findFunctions(code, parser) {
  * runtime discards the stub bodies, so pin identity must close over the
  * group and resolution must prefer the implementation.
  */
+/**
+ * A member a subclass or a structural satisfier must supply: decorated
+ * abstract (`@abstractmethod` and its older `abstract*` spellings), or
+ * declared in a class that lists `Protocol` among its bases (a protocol
+ * class; a class that merely inherits from one is an implementation).
+ */
+const PY_ABSTRACT_DECORATORS = new Set(['abstractmethod', 'abstractproperty',
+    'abstractclassmethod', 'abstractstaticmethod']);
+
+// The names a module uses for `Protocol` and for the abstract decorators:
+// the plain spellings, plus what `from m import Protocol as P` binds. A
+// module alias (`import typing as t`) needs nothing: `t.Protocol` ends in
+// the plain spelling.
+const contractSpellingsByTree = new WeakMap();
+function contractSpellings(node) {
+    let spellings = contractSpellingsByTree.get(node.tree);
+    if (spellings) return spellings;
+    spellings = { protocol: new Set(['Protocol']), abstract: new Set(PY_ABSTRACT_DECORATORS) };
+    for (const statement of node.tree.rootNode.descendantsOfType('import_from_statement')) {
+        for (const part of statement.namedChildren) {
+            if (part.type !== 'aliased_import') continue;
+            const imported = part.childForFieldName('name')?.text.split('.').pop();
+            const alias = part.childForFieldName('alias')?.text;
+            if (!alias) continue;
+            if (imported === 'Protocol') spellings.protocol.add(alias);
+            if (PY_ABSTRACT_DECORATORS.has(imported)) spellings.abstract.add(alias);
+        }
+    }
+    contractSpellingsByTree.set(node.tree, spellings);
+    return spellings;
+}
+
+/** Does the class list Protocol among its bases (PEP 544 protocol class)? */
+function isProtocolClass(classNode) {
+    const { protocol } = contractSpellings(classNode);
+    return extractBases(classNode).some(base => protocol.has(String(base).split('.').pop()));
+}
+
+function isRequiredPythonMember(classNode, decorators) {
+    const { abstract } = contractSpellings(classNode);
+    if ((decorators || []).some(decorator =>
+        abstract.has(String(decorator).replace(/\(.*$/s, '').split('.').pop().trim()))) return true;
+    return isProtocolClass(classNode);
+}
+
 function isOverloadDecorated(decorators) {
     return decorators.some(d => {
         const head = d.split('(')[0].trim();
@@ -1270,7 +1321,10 @@ function extractClassMembers(classNode, code) {
                     ...(paramTypes && { paramTypes }),
                     ...(docstring && { docstring }),
                     ...(memberDecorators.length > 0 && { decorators: memberDecorators }),
+                    ...(memberDecorators.length > 0 && { registrationUnknown: require('../core/python-binding-identity').registrationUnknown(funcNode) }),
+                    runtimeOwnerPath: require('../core/python-binding-identity').pythonRuntimeOwners(funcNode),
                     ...(isOverloadDecorated(memberDecorators) && { isSignature: true }),
+                    ...(isRequiredPythonMember(classNode, memberDecorators) && { requiredMember: true }),
                     ...(nameLine !== startLine && { nameLine })
                 });
             }
@@ -2678,6 +2732,7 @@ function pythonModuleAliases(tree) {
 
 // Annotation positions whose value Python evaluates as an expression.
 const PY_ANNOTATION_OWNERS = new Set(['typed_parameter', 'typed_default_parameter', 'function_definition', 'assignment']);
+const annotationQuotesByTree = new WeakMap();
 
 /**
  * String annotations holding calls (fix #398F): `def f(v: "Annotated[int,
@@ -2687,9 +2742,13 @@ const PY_ANNOTATION_OWNERS = new Set(['typed_parameter', 'typed_default_paramete
  * interpolation); the result lists the byte ranges of their quotes.
  */
 function annotationStringQuotes(tree) {
+    const cached = annotationQuotesByTree.get(tree);
+    if (cached) return cached;
     const quotes = [];
-    for (const holder of getCachedNodeList(tree.rootNode).nodes) {
-        if (holder.type !== 'type') continue;
+    // The source tree is immutable. A multi-name query should discover
+    // these file-level ranges once, without rebuilding a flat node list
+    // whenever another file displaces the general traversal cache.
+    for (const holder of tree.rootNode.descendantsOfType('type')) {
         const string = holder.namedChildCount === 1 ? holder.namedChild(0) : null;
         if (string?.type !== 'string' || string.startPosition.row !== string.endPosition.row) continue;
         const owner = holder.parent;
@@ -2706,6 +2765,7 @@ function annotationStringQuotes(tree) {
         quotes.push({ open: parts[0].startIndex, close: parts[2].startIndex,
             contentStart: content.startIndex, contentEnd: content.endIndex });
     }
+    annotationQuotesByTree.set(tree, quotes);
     return quotes;
 }
 
@@ -3834,7 +3894,10 @@ function findCallsInTree(code, tree, parser, sink = null) {
             const callArgsNode = node.childForFieldName('arguments');
             let argCount = 0;
             let argSpread = false;
-            if (callArgsNode) {
+            if (callArgsNode?.type === 'generator_expression') {
+                // `f(x for x in xs)`: the bare generator is the one argument.
+                argCount = 1;
+            } else if (callArgsNode) {
                 for (let i = 0; i < callArgsNode.namedChildCount; i++) {
                     const arg = callArgsNode.namedChild(i);
                     if (arg.type.endsWith('comment')) continue;
@@ -5485,6 +5548,1439 @@ function extractConstructorName(node) {
     return null;
 }
 
+
+// Bases every class may name without bringing a constructor or a test.
+// (typing.Protocol brings no test and no __new__; the constructor it gives
+// the class that lists it is read with that class.)
+const PYTHON_PLAIN_BASES = new Set(['object', 'ABC', 'Generic', 'Protocol']);
+// The two members by which pytest refuses a class: a constructor that is not object's.
+const PYTHON_CONSTRUCTORS = ['__init__', '__new__'];
+// Statements whose blocks run only sometimes.
+const PY_BRANCHING = new Set(['if_statement', 'elif_clause', 'else_clause', 'try_statement', 'except_clause',
+    'except_group_clause', 'finally_clause', 'with_statement', 'for_statement', 'while_statement',
+    'match_statement', 'case_clause']);
+// What stops a test before its body runs: pytest's and unittest's own
+// names for skipping, leaving, failing and marking, wherever a setup, a
+// fixture or a hook mentions one.
+const PY_STOPPING_NAMES = new Set(['skip', 'skipTest', 'SkipTest', 'importorskip', 'xfail', 'exit', 'fail',
+    'deselect', 'add_marker', 'applymarker', 'shouldstop', 'shouldfail', 'Skipped', 'Exit', 'getfixturevalue']);
+const PY_STOPPING_PATHS = /^(pytest\.(skip|importorskip|exit|xfail|fail)|unittest\.(case\.)?SkipTest|_pytest\.outcomes\.\w+|nose\.SkipTest)(\.|$)/;
+// Names through which a module's or a class's names are written without
+// an assignment to them.
+const PY_NAMESPACE_NAMES = new Set(['globals', 'vars', 'locals', 'setattr', 'exec', 'eval', '__dict__', '__setattr__']);
+const PY_FIXTURE_PATHS = new Set(['pytest.fixture', 'pytest.yield_fixture', 'pytest_asyncio.fixture']);
+const PY_ABSTRACT_PATHS = new Set(['abc.abstractmethod', 'abc.abstractproperty', 'abc.abstractclassmethod',
+    'abc.abstractstaticmethod']);
+// Functions the runner calls by their names before the tests of a module
+// or of a class.
+const PY_MODULE_SETUPS = new Set(['setup_module', 'setup_function', 'setUpModule']);
+const PY_CLASS_SETUPS = new Set(['setup_class', 'setup_method', 'setUp', 'setUpClass', 'asyncSetUp', 'setup']);
+// pytest hooks called for one test or one collected node: one in a
+// conftest.py holds for what is collected below that file. Every other
+// hook is called once for the whole run, whichever conftest.py has it.
+const PYTEST_NODE_HOOKS = new Set(['pytest_runtest_protocol', 'pytest_runtest_logstart', 'pytest_runtest_logfinish',
+    'pytest_runtest_setup', 'pytest_runtest_call', 'pytest_runtest_teardown', 'pytest_runtest_makereport',
+    'pytest_pyfunc_call', 'pytest_collect_file', 'pytest_collect_directory', 'pytest_ignore_collect',
+    'pytest_pycollect_makemodule', 'pytest_pycollect_makeitem', 'pytest_generate_tests', 'pytest_itemcollected',
+    'pytest_collectstart', 'pytest_make_collect_report', 'pytest_collectreport', 'pytest_fixture_setup',
+    'pytest_fixture_post_finalizer', 'pytest_make_parametrize_id']);
+// pytest hooks whose return value only words a report.
+const PYTEST_REPORTING_HOOKS = new Set(['pytest_report_header', 'pytest_report_collectionfinish',
+    'pytest_report_teststatus', 'pytest_make_parametrize_id', 'pytest_assertrepr_compare',
+    'pytest_report_to_serializable', 'pytest_report_from_serializable']);
+// What a hook may call on the objects pytest hands it without changing
+// what is collected or run; the second set gives back another such object.
+const PYTEST_HOOK_READS = new Set(['getoption', 'getini', 'getvalue', 'addoption', 'addini', 'getgroup',
+    'addinivalue_line', 'get_closest_marker', 'iter_markers', 'write_line', 'write_sep', 'write', 'section',
+    'startswith', 'endswith', 'hasplugin', 'has_plugin', 'getplugin', 'get_plugin', 'is_registered', 'isatty']);
+const PYTEST_HOOK_OBJECTS = new Set(['getgroup', 'get_closest_marker', 'iter_markers', 'getplugin', 'get_plugin']);
+const PY_TRUTH_TESTS = new Set(['if_statement', 'elif_clause', 'while_statement', 'not_operator', 'boolean_operator',
+    'comparison_operator', 'conditional_expression', 'assert_statement', 'expression_statement']);
+// Values that are no function and no class, whatever name holds them.
+const PY_PLAIN_VALUES = new Set(['none', 'true', 'false', 'integer', 'float', 'string', 'concatenated_string',
+    'list', 'tuple', 'dictionary', 'set', 'list_comprehension', 'dictionary_comprehension', 'set_comprehension',
+    'generator_expression', 'ellipsis']);
+
+/**
+ * What a Python file declares for pytest (measured on pytest 9), read from
+ * this file alone: what the names of the module and of its classes are
+ * bound to once the module has run. Who collects what is settled where
+ * the files are put together (core/test-units.js), because a class runs
+ * the tests of the classes it derives from, a module runs the tests it
+ * imports, and a conftest.py decides for the modules beside it.
+ *
+ * Every write to a name counts, read from the syntax tree in the order
+ * the module runs: the last write that always runs decides, together with
+ * every later one that runs only sometimes (in a branch, a loop, a try).
+ * Of two definitions the last is the one that exists; a definition
+ * followed by `name = None` or `del name` is gone; one inside a branch
+ * exists only sometimes. A name bound to another name of the module (an
+ * alias) or to a lambda is one more test, listed; a test-shaped name bound
+ * to anything else that could be a function or a class, a star import of
+ * a module that is not read, and code that writes the module's names
+ * through globals(), setattr and the like leave tests this does not list
+ * (`inheriting`: the file's count is a lower bound).
+ *
+ * `__test__` is read as pytest reads it: false switches a module, a class
+ * (and every class deriving from it) or a function off; the literal True
+ * makes a class or a function a test whatever it is called; a value that
+ * is not a literal leaves both open (`enabled`, `forced`: 'unknown'). A
+ * write of it that is none of the forms read (through another name, a
+ * string, a function) leaves every switch of the file open.
+ *
+ * A decorator is read by what it is imported as: pytest's and unittest's
+ * marks (skip: declared and not executed; skipif: sometimes; xfail with
+ * run=False: not executed; an empty parametrize: not executed), the
+ * fixtures a test asks for by usefixtures, unittest.mock's patches
+ * (nothing changes), a name of this file bound once to one of pytest's
+ * marks. Any other decorator may do anything: the test is conditional.
+ *
+ * Code that runs before a test's body can stop it: the module's own
+ * statements (pytest.importorskip, pytest.skip, a raise, a function of
+ * the module that does one of these, outside `if __name__ == "__main__"`),
+ * setup functions (setup_module, setUp, ...), fixtures and, in a
+ * conftest.py or a plugin module, hooks. `runtime` says what this file
+ * does as a plugin: whether one of its hooks can change what is collected
+ * or run (it mentions a stopping name, raises, yields, returns a value
+ * where the value decides, or uses what pytest hands it other than by the
+ * few calls that only read), whether such a hook is one pytest calls
+ * once for the whole run (`everywhere`) and not for one test, which
+ * fixtures it defines and whether each can stop a test, and which modules
+ * it loads as plugins. A setup, a fixture or the module itself that calls
+ * a function of another module of the project names the call (`calls`,
+ * `guardCalls`, `skipCalls`), and `stopping` names the module's own
+ * functions that can stop a test: the two are matched where the files are
+ * put together, one module deep (`runtime.hookCalls` for hooks).
+ *
+ * "classes" says, for every class, what it derives from and which
+ * test-shaped members it declares; "functions" every function of the
+ * module's top; "imports" the names it takes from other modules or binds
+ * to other names of its own; "marks" pytest's marks by name, for the
+ * runner's mark expression. A module whose name is outside python_files
+ * is not collected: it declares for others and has no test of its own.
+ */
+function testUnits(fileEntry, helpers) {
+    const collection = helpers.collection || {};
+    const matches = (patterns, fallback, name) => (patterns && patterns.length > 0 ? patterns : fallback)
+        .some(pattern => /[*?[]/.test(pattern) ? helpers.glob(pattern, name) : name.startsWith(pattern));
+    const functionNamed = name => matches(collection.functions, ['test'], name);
+    const classNamed = name => matches(collection.classes, ['Test'], name);
+    const symbols = fileEntry.symbols || [];
+    const tree = helpers.tree();
+    if (!tree) return null;
+    const root = tree.rootNode;
+
+    // What an imported name stands for: "from unittest import TestCase as
+    // Base" makes Base the TestCase of unittest.
+    const imported = new Map();
+    for (const binding of fileEntry.importBindings || []) {
+        imported.set(binding.alias || binding.name, binding);
+    }
+    const inProject = moduleName => !!(fileEntry.moduleResolved || {})[moduleName];
+    const origin = written => {
+        const parts = String(written).split('.');
+        const binding = imported.get(parts[0]);
+        if (!binding) return { name: parts[parts.length - 1], module: null, bound: false };
+        if (binding.kind !== 'import') {
+            return { name: parts.length > 1 ? parts[parts.length - 1] : binding.name, module: binding.module, bound: true };
+        }
+        return { name: parts[parts.length - 1], module: [binding.module, ...parts.slice(1, -1)].join('.'), bound: true };
+    };
+    const basesOf = cls => (Array.isArray(cls.extends) ? cls.extends : String(cls.extends || '').split(','))
+        .map(base => String(base).trim()).filter(base => base && base !== 'object');
+    const holds = (cls, symbol) => symbol.className === cls.name && symbol.startLine >= cls.startLine &&
+        (symbol.endLine ?? symbol.startLine) <= (cls.endLine ?? cls.startLine);
+
+    // ---- the writes of the module and of each class body, in order ----
+    const dotted = node => {
+        if (!node) return null;
+        if (node.type === 'identifier') return node.text;
+        if (node.type !== 'attribute') return null;
+        const object = dotted(node.childForFieldName('object'));
+        const attribute = node.childForFieldName('attribute');
+        return object && attribute ? `${object}.${attribute.text}` : null;
+    };
+    const scopeWrites = new Map(); // 'module' or a class node's id -> name -> writes
+    const attributeWrites = new Map(); // '<scope>\0<name>' -> writes of <name>.__test__ in that scope
+    const constructorWrites = new Set(); // names of the module whose __init__ or __new__ is written from outside the class
+    const definitions = new Map(); // row of a def's or class's name -> { node, straight, scope }
+    const accounted = new Set(); // start offsets of the __test__ and pytestmark names read as writes
+    const stars = []; // modules whose every name the module takes
+    const note = (scope, name, write) => {
+        if (!scopeWrites.has(scope)) scopeWrites.set(scope, new Map());
+        const names = scopeWrites.get(scope);
+        if (!names.has(name)) names.set(name, []);
+        names.get(name).push(write);
+    };
+    const targetsOf = (node, out = []) => {
+        if (!node) return out;
+        if (node.type === 'identifier') out.push(node);
+        else if (node.type !== 'attribute' && node.type !== 'subscript') {
+            for (const child of node.namedChildren) targetsOf(child, out);
+        }
+        return out;
+    };
+    const visitExpression = (node, scope, straight) => {
+        if (!node) return;
+        if (node.type === 'assignment' || node.type === 'augmented_assignment') {
+            const left = node.childForFieldName('left');
+            let value = node.childForFieldName('right');
+            // a = b = value: every target gets the last value.
+            while (value && value.type === 'assignment') {
+                visitExpression(value, scope, straight);
+                value = value.childForFieldName('right');
+            }
+            const kind = node.type === 'augmented_assignment' ? 'augment' : value ? 'assign' : 'annotation';
+            const write = {
+                kind, value: kind === 'assign' ? value : null, straight, pos: node.startIndex,
+                line: node.startPosition.row + 1, endLine: node.endPosition.row + 1,
+            };
+            if (left && left.type === 'identifier') {
+                if (kind !== 'annotation') {
+                    note(scope, left.text, write);
+                    accounted.add(left.startIndex);
+                }
+            } else if (left && left.type === 'attribute') {
+                const object = left.childForFieldName('object');
+                const attribute = left.childForFieldName('attribute');
+                if (object && object.type === 'identifier' && attribute && attribute.text === '__test__') {
+                    const key = `${scope}\0${object.text}`;
+                    if (!attributeWrites.has(key)) attributeWrites.set(key, []);
+                    attributeWrites.get(key).push(write);
+                    accounted.add(attribute.startIndex);
+                } else if (object && object.type === 'identifier' && attribute && PYTHON_CONSTRUCTORS.includes(attribute.text)) {
+                    constructorWrites.add(object.text);
+                }
+            } else {
+                for (const target of targetsOf(left)) note(scope, target.text, { ...write, kind: 'other', value: null });
+            }
+            return;
+        }
+        if (node.type === 'named_expression') {
+            const name = node.childForFieldName('name');
+            if (name) note(scope, name.text, { kind: 'other', value: null, straight, pos: node.startIndex });
+        }
+    };
+    const visitStatement = (statement, scope, straight) => {
+        let node = statement;
+        if (node.type === 'decorated_definition') node = node.childForFieldName('definition') || node;
+        if (node.type === 'function_definition' || node.type === 'class_definition') {
+            const name = node.childForFieldName('name');
+            if (!name) return;
+            const kind = node.type === 'class_definition' ? 'class' : 'def';
+            note(scope, name.text, { kind, value: null, straight, pos: statement.startIndex, node });
+            definitions.set(name.startPosition.row, { node, straight, scope, pos: statement.startIndex, holder: statement });
+            if (kind === 'class') {
+                const body = node.childForFieldName('body');
+                for (const child of body ? body.namedChildren : []) visitStatement(child, node.id, true);
+            }
+            return;
+        }
+        if (node.type === 'expression_statement') {
+            for (const child of node.namedChildren) visitExpression(child, scope, straight);
+            return;
+        }
+        if (node.type === 'import_statement' || node.type === 'import_from_statement') {
+            for (const part of node.namedChildren) {
+                if (part.type === 'wildcard_import') {
+                    const from = node.childForFieldName('module_name');
+                    if (from && scope === 'module') stars.push({ module: from.text, line: node.startPosition.row + 1, straight });
+                    continue;
+                }
+                if (node.type === 'import_from_statement' && sameNode(part, node.childForFieldName('module_name'))) continue;
+                const bound = part.type === 'aliased_import' ? part.childForFieldName('alias')
+                    : part.type === 'dotted_name' ? (node.type === 'import_statement' ? part.namedChild(0)
+                        : part.namedChild(part.namedChildCount - 1)) : null;
+                if (bound) note(scope, bound.text, { kind: 'import', value: null, straight, pos: node.startIndex, line: node.startPosition.row + 1 });
+            }
+            return;
+        }
+        if (node.type === 'delete_statement') {
+            for (const target of targetsOf(node)) {
+                note(scope, target.text, { kind: 'del', value: null, straight, pos: node.startIndex });
+                accounted.add(target.startIndex);
+            }
+            return;
+        }
+        if (!PY_BRANCHING.has(node.type) && node.type !== 'block') return;
+        if (node.type === 'for_statement') {
+            for (const target of targetsOf(node.childForFieldName('left'))) {
+                note(scope, target.text, { kind: 'other', value: null, straight: false, pos: node.startIndex });
+            }
+        }
+        for (const child of node.namedChildren) {
+            if (child.type === 'block') {
+                for (const inner of child.namedChildren) visitStatement(inner, scope, false);
+            } else if (PY_BRANCHING.has(child.type)) {
+                visitStatement(child, scope, false);
+            } else if (child.type === 'as_pattern' || child.type === 'with_clause') {
+                // with ... as name, except ... as name
+                const walk = part => {
+                    if (part.type === 'as_pattern_target') {
+                        for (const target of targetsOf(part)) {
+                            note(scope, target.text, { kind: 'other', value: null, straight: false, pos: part.startIndex });
+                        }
+                        return;
+                    }
+                    for (const next of part.namedChildren) walk(next);
+                };
+                walk(child);
+            }
+        }
+    };
+    for (const statement of root.namedChildren) visitStatement(statement, 'module', true);
+    const writesOf = (scope, name) => (scopeWrites.get(scope) || new Map()).get(name) || [];
+    /** The writes that may be the last: the last one that always runs, and every later one. */
+    const candidatesOf = writes => {
+        if (!writes || writes.length === 0) return [];
+        let last = -1;
+        writes.forEach((write, i) => {
+            if (write.straight) last = i;
+        });
+        return last === -1 ? [null, ...writes] : writes.slice(last);
+    };
+    /** The one write a name has for certain, or null. */
+    const settled = (scope, name) => {
+        const candidates = candidatesOf(writesOf(scope, name));
+        return candidates.length === 1 && candidates[0] ? candidates[0] : null;
+    };
+    /**
+     * The full path a written name stands for: by the file's imports, and
+     * through the names of the module bound once to such a name.
+     */
+    const pathOf = (written, depth = 0) => {
+        const parts = String(written).split('.');
+        const binding = imported.get(parts[0]);
+        if (binding) {
+            if (binding.kind === 'import') return [binding.module, ...parts.slice(1)].join('.');
+            return [binding.module, binding.name, ...parts.slice(1)].join('.');
+        }
+        const write = depth < 4 ? settled('module', parts[0]) : null;
+        const target = write && write.kind === 'assign' ? dotted(write.value) : null;
+        return target ? pathOf([target, ...parts.slice(1)].join('.'), depth + 1) : null;
+    };
+    const unwrapped = node => {
+        let current = node;
+        while (current && current.type === 'parenthesized_expression') current = current.namedChildren[0];
+        return current;
+    };
+    const truthOf = node => {
+        const value = unwrapped(node);
+        if (!value) return null;
+        switch (value.type) {
+            case 'true': return true;
+            case 'false': case 'none': return false;
+            case 'integer': case 'float': return Number(value.text.replace(/_/g, '')) !== 0;
+            case 'string': return value.namedChildren.some(child => child.type === 'interpolation') ? null
+                : value.namedChildren.some(child => child.type === 'string_content');
+            default: return null;
+        }
+    };
+    const stringOf = node => {
+        const value = unwrapped(node);
+        if (!value || value.type !== 'string' || value.namedChildren.some(child => child.type === 'interpolation')) return null;
+        return value.namedChildren.filter(child => child.type === 'string_content').map(child => child.text).join('');
+    };
+    /** A written-out list or tuple, or what a name of the module bound once to one holds. */
+    const sequenceOf = (node, depth = 0) => {
+        const value = unwrapped(node);
+        if (!value) return null;
+        if (value.type === 'list' || value.type === 'tuple') return value;
+        if (value.type === 'identifier' && depth < 4 && !imported.has(value.text)) {
+            const write = settled('module', value.text);
+            return write && write.kind === 'assign' ? sequenceOf(write.value, depth + 1) : null;
+        }
+        return null;
+    };
+    const UNSET = Symbol('unset');
+    const OPEN_SWITCH = Object.freeze({ on: 'unknown', forced: 'unknown' });
+    /**
+     * What `__test__` is once its scope has run: `on` (true, false,
+     * 'unknown') and `forced` (it is the literal True: pytest takes the
+     * class or function whatever it is called). Undefined: never written.
+     */
+    const switchValue = writes => {
+        const candidates = candidatesOf(writes);
+        if (candidates.length === 0) return undefined;
+        const values = candidates.map(write => {
+            if (write === null || write.kind === 'del') return UNSET;
+            const truth = write.kind === 'assign' ? truthOf(write.value) : null;
+            if (truth == null) return OPEN_SWITCH;
+            return { on: truth, forced: truth && unwrapped(write.value).type === 'true' };
+        });
+        if (values.every(value => value === UNSET)) return undefined;
+        if (values.some(value => value === UNSET)) return OPEN_SWITCH;
+        const same = key => values.every(value => value[key] === values[0][key]) ? values[0][key] : 'unknown';
+        return { on: same('on'), forced: same('forced') };
+    };
+
+    // Any use of the two names that is none of the writes read, a string
+    // that spells one: nothing about them is settled.
+    let switchUnsettled = false;
+    let marksUnsettled = false;
+    const scan = node => {
+        if (node.type === 'identifier' && !accounted.has(node.startIndex)) {
+            if (node.text === '__test__') switchUnsettled = true;
+            else if (node.text === 'pytestmark') marksUnsettled = true;
+        } else if (node.type === 'string_content') {
+            if (node.text === '__test__') switchUnsettled = true;
+            else if (node.text === 'pytestmark') marksUnsettled = true;
+        }
+        for (const child of node.namedChildren) scan(child);
+    };
+    if (/__test__|pytestmark/.test(root.text)) scan(root);
+    // A switch written on a name is read only where the name is one
+    // definition or one import of its scope: any other object is not followed.
+    // A name the module never writes and takes by a star import is one.
+    const starBound = (scope, name) => scope === 'module' && stars.length > 0 && !imported.has(name) &&
+        writesOf('module', name).length === 0;
+    for (const key of attributeWrites.keys()) {
+        const [scope, name] = key.split('\0');
+        const scopeKey = scope === 'module' ? 'module' : Number(scope);
+        const writes = writesOf(scopeKey, name);
+        if (starBound(scopeKey, name)) continue;
+        if (writes.length !== 1 || !['def', 'class', 'import'].includes(writes[0].kind)) switchUnsettled = true;
+    }
+    const attributeSwitch = (scope, name) => switchValue(attributeWrites.get(`${scope}\0${name}`));
+
+    // ---- rows of parameters ----
+    const functionsNamed = new Map(); // names of the module's top -> their definition nodes
+    for (const info of definitions.values()) {
+        if (info.scope !== 'module' || info.node.type !== 'function_definition') continue;
+        const name = info.node.childForFieldName('name').text;
+        if (!functionsNamed.has(name)) functionsNamed.set(name, []);
+        functionsNamed.get(name).push(info.node);
+    }
+    const parameterNames = fn => {
+        const names = [];
+        const list = fn.childForFieldName('parameters');
+        for (const parameter of list ? list.namedChildren : []) {
+            let name = parameter.type === 'identifier' ? parameter : parameter.childForFieldName('name');
+            if (!name && (parameter.type === 'list_splat_pattern' || parameter.type === 'dictionary_splat_pattern')) {
+                name = parameter.namedChildren[0];
+            }
+            if (name && name.type === 'identifier') names.push(name.text);
+        }
+        return names;
+    };
+    // Names some class body writes: in a decorator inside that class the
+    // name is the class's, which is not followed.
+    const classWritten = new Set();
+    for (const [scope, names] of scopeWrites) {
+        if (scope !== 'module') for (const name of names.keys()) classWritten.add(name);
+    }
+    const RUN = 'run';
+    /**
+     * What a row of a table of parameters does to the body of the test:
+     * 'run' (the body executes with it), 'skip' (the row's own marks leave
+     * the body out), 'sometimes', or { via } where a name of another
+     * module of the project decides. Only pytest.param makes a row that
+     * carries marks: a value written out, a class, a function, a name of
+     * the module bound once to one of those is a plain row. A name, a
+     * member or a call that is not read may be a marked one.
+     */
+    const rowState = (node, depth = 0) => {
+        const value = unwrapped(node);
+        if (!value || depth > 4) return 'sometimes';
+        switch (value.type) {
+            // The value of an operator is no row, whatever its operands are.
+            case 'lambda': case 'comparison_operator': case 'not_operator': case 'unary_operator': case 'binary_operator':
+                return RUN;
+            case 'boolean_operator':
+                return value.namedChildren.every(part => rowState(part, depth + 1) === RUN) ? RUN : 'sometimes';
+            case 'conditional_expression': {
+                const parts = value.namedChildren;
+                return parts.length === 3 && rowState(parts[0], depth + 1) === RUN && rowState(parts[2], depth + 1) === RUN
+                    ? RUN : 'sometimes';
+            }
+            case 'identifier': return nameState(value.text, depth);
+            case 'attribute': return memberState(value, depth);
+            case 'call': return callState(value, depth);
+            default: return PY_PLAIN_VALUES.has(value.type) ? RUN : 'sometimes';
+        }
+    };
+    const writeState = (candidates, depth) => {
+        if (candidates.length !== 1 || !candidates[0]) return 'sometimes';
+        const write = candidates[0];
+        if (write.kind === 'def' || write.kind === 'class') return RUN;
+        return write.kind === 'assign' ? rowState(write.value, depth + 1) : 'sometimes';
+    };
+    const nameState = (name, depth) => {
+        if (classWritten.has(name)) return 'sometimes';
+        const candidates = candidatesOf(writesOf('module', name));
+        const binding = imported.get(name);
+        if (binding && candidates.length === 1 && candidates[0] && candidates[0].kind === 'import') {
+            // A module is no row; a name of another module of the project is read there.
+            if (binding.kind === 'import') return RUN;
+            return inProject(binding.module) ? { via: { module: binding.module, name: binding.name } } : RUN;
+        }
+        // A name the module never binds is a builtin.
+        if (candidates.length === 0) return stars.length === 0 && !binding ? RUN : 'sometimes';
+        return writeState(candidates, depth);
+    };
+    const memberState = (node, depth) => {
+        const written = dotted(node);
+        if (!written) return 'sometimes';
+        const parts = written.split('.');
+        if (classWritten.has(parts[0])) return 'sometimes';
+        const binding = imported.get(parts[0]);
+        if (binding) {
+            const path = pathOf(written);
+            if (path && /^_?pytest(\.|$)/.test(path)) return 'sometimes';
+            const held = candidatesOf(writesOf('module', parts[0]));
+            if (held.length !== 1 || !held[0] || held[0].kind !== 'import') return 'sometimes';
+            if (!inProject(binding.module)) return RUN;
+            if (parts.length === 2 && binding.kind === 'import') return { via: { module: binding.module, name: parts[1] } };
+            // A member of a class taken by name, or a name of a module taken from its package.
+            if (parts.length === 2) return { via: { module: binding.module, name: binding.name, member: parts[1] } };
+            return 'sometimes';
+        }
+        const candidates = candidatesOf(writesOf('module', parts[0]));
+        if (candidates.length === 0) return stars.length === 0 ? RUN : 'sometimes';
+        // A member of a class of the module, where the class body binds it.
+        if (parts.length !== 2 || candidates.length !== 1 || !candidates[0] || candidates[0].kind !== 'class') return 'sometimes';
+        const members = candidatesOf(writesOf(candidates[0].node.id, parts[1]));
+        return members.length === 0 ? 'sometimes' : writeState(members, depth);
+    };
+    const argumentsOf = call => {
+        const args = call.childForFieldName('arguments');
+        return (args ? args.namedChildren : []).filter(argument => argument.type !== 'comment');
+    };
+    const callState = (call, depth) => {
+        const callee = call.childForFieldName('function');
+        const written = dotted(callee);
+        const parts = written ? written.split('.') : [];
+        const binding = written ? imported.get(parts[0]) : null;
+        const path = binding ? pathOf(written) : null;
+        const given = argumentsOf(call);
+        // Calling what a call gave back: a row only where that could be one.
+        if (callee && callee.type === 'call') {
+            if (given.some(argument => argument.type === 'list_splat' || argument.type === 'dictionary_splat' ||
+                carriesRows(argument.type === 'keyword_argument' ? argument.childForFieldName('value') : argument, null, depth + 1))) {
+                return 'sometimes';
+            }
+            return callState(callee, depth + 1) === RUN ? RUN : 'sometimes';
+        }
+        if (path === 'pytest.param') {
+            if (given.some(argument => argument.type === 'list_splat' || argument.type === 'dictionary_splat')) return 'sometimes';
+            const marks = given.find(argument => argument.type === 'keyword_argument' &&
+                argument.childForFieldName('name')?.text === 'marks');
+            if (!marks) return RUN;
+            const read = marksOfValue(unwrapped(marks.childForFieldName('value')));
+            // pytest refuses a row that asks for fixtures.
+            if (read.unread || read.fixturesOpen || read.marks.includes('usefixtures')) return 'sometimes';
+            return read.skip === 'skip' ? 'skip' : read.skip === 'sometimes' ? 'sometimes' : RUN;
+        }
+        if (path && /^_?pytest(\.|$)/.test(path)) return 'sometimes';
+        // What is handed in may come back out.
+        if (given.some(argument => argument.type === 'list_splat' || argument.type === 'dictionary_splat' ||
+            carriesRows(argument.type === 'keyword_argument' ? argument.childForFieldName('value') : argument, null, depth + 1))) {
+            return 'sometimes';
+        }
+        if (!written || classWritten.has(parts[0])) return 'sometimes';
+        if (binding) {
+            const candidates = candidatesOf(writesOf('module', parts[0]));
+            if (candidates.length !== 1 || !candidates[0] || candidates[0].kind !== 'import') return 'sometimes';
+            // What a package's code gives back is not read.
+            if (!inProject(binding.module)) return RUN;
+            if (parts.length === 1 && binding.kind !== 'import') return { via: { module: binding.module, name: binding.name, call: true } };
+            if (parts.length === 2 && binding.kind === 'import') return { via: { module: binding.module, name: parts[1], call: true } };
+            if (parts.length === 2) return { via: { module: binding.module, name: binding.name, member: parts[1], call: true } };
+            return 'sometimes';
+        }
+        const candidates = candidatesOf(writesOf('module', parts[0]));
+        if (candidates.length === 0) return stars.length === 0 ? RUN : 'sometimes';
+        if (parts.length !== 1 || candidates.length !== 1 || !candidates[0]) return 'sometimes';
+        // An instance of a class of the module; what a function of the module gives back.
+        if (candidates[0].kind === 'class') return RUN;
+        return candidates[0].kind === 'def' && !makesRows(candidates[0].node, depth + 1) ? RUN : 'sometimes';
+    };
+    /**
+     * Does an expression or a body hold anything that is a marked row or
+     * may give one: pytest's param, a keyword `marks`, a name that is not
+     * a plain row, a call that may give one back, the module's namespace.
+     * `locals`: names of the function around it, which are what it was
+     * handed.
+     */
+    const carriesRows = (node, locals, depth) => {
+        if (!node) return false;
+        if (depth > 6) return true;
+        switch (node.type) {
+            case 'keyword_argument':
+                if (node.childForFieldName('name')?.text === 'marks') return true;
+                return carriesRows(node.childForFieldName('value'), locals, depth);
+            case 'identifier': {
+                const name = node.text;
+                if (name === 'param' || name === 'ParameterSet' || PY_NAMESPACE_NAMES.has(name)) return true;
+                if (locals && locals.has(name)) return false;
+                return nameState(name, depth + 1) !== RUN;
+            }
+            case 'attribute': {
+                const written = dotted(node);
+                if (!written) return carriesRows(node.childForFieldName('object'), locals, depth);
+                const name = node.childForFieldName('attribute').text;
+                if (name === 'param' || name === 'ParameterSet' || PY_NAMESPACE_NAMES.has(name)) return true;
+                if (locals && locals.has(written.split('.')[0])) return false;
+                return memberState(node, depth + 1) !== RUN;
+            }
+            case 'call': {
+                const callee = node.childForFieldName('function');
+                const written = dotted(callee);
+                const root = written ? written.split('.')[0] : null;
+                if (!(root && locals && locals.has(root)) && callState(node, depth + 1) !== RUN) return true;
+                return argumentsOf(node).some(argument => carriesRows(argument, locals, depth));
+            }
+            default:
+                return node.namedChildren.some(child => carriesRows(child, locals, depth));
+        }
+    };
+    const makesMemo = new Map();
+    /** Can a function of the module's top give back a marked row? */
+    const makesRows = (fn, depth = 0) => {
+        if (makesMemo.has(fn.id)) return makesMemo.get(fn.id);
+        // A function that calls itself adds nothing by that.
+        makesMemo.set(fn.id, false);
+        const locals = new Set(parameterNames(fn));
+        const body = fn.childForFieldName('body');
+        // Names the body binds are what it computed from the rest.
+        const bind = node => {
+            if (node.type === 'assignment' || node.type === 'augmented_assignment' || node.type === 'named_expression') {
+                for (const target of targetsOf(node.childForFieldName('left') || node.childForFieldName('name'))) locals.add(target.text);
+            } else if (node.type === 'for_statement' || node.type === 'for_in_clause') {
+                for (const target of targetsOf(node.childForFieldName('left'))) locals.add(target.text);
+            }
+            for (const child of node.namedChildren) bind(child);
+        };
+        if (body) bind(body);
+        const answer = !body || carriesRows(body, locals, depth);
+        makesMemo.set(fn.id, answer);
+        return answer;
+    };
+    const NO_TABLE = Object.freeze({ skip: null });
+    /**
+     * What a table of parameters leaves of a test: nothing where one row
+     * runs; `skip` ('skip': no row runs the body; 'sometimes': one may);
+     * `table` where names of other modules of the project decide (`rest`:
+     * what the other rows say).
+     */
+    const tableState = values => {
+        const rows = [];
+        let open = false; // a part that is not written out may be empty
+        const add = (list, depth) => {
+            for (const item of list.namedChildren) {
+                if (item.type === 'comment') continue;
+                if (item.type === 'list_splat') {
+                    const inner = depth < 4 ? sequenceOf(item.namedChildren[0]) : null;
+                    if (inner) add(inner, depth + 1);
+                    // The characters of a text written out are plain rows.
+                    else if (stringOf(item.namedChildren[0])) rows.push(RUN);
+                    else open = true;
+                    continue;
+                }
+                rows.push(rowState(item));
+            }
+        };
+        add(values, 0);
+        if (rows.some(state => state === RUN)) return NO_TABLE;
+        if (rows.length === 0) return { skip: open ? 'sometimes' : 'skip' };
+        const via = rows.filter(state => typeof state === 'object').map(state => state.via);
+        const rest = !open && rows.every(state => typeof state === 'object' || state === 'skip') ? 'skip' : 'sometimes';
+        return via.length === 0 ? { skip: rest } : { skip: null, table: { rest, via } };
+    };
+
+    // ---- decorators and marks ----
+    const NOTHING = Object.freeze({ skip: null, marks: [], open: false, fixtures: [], fixturesOpen: false });
+    const UNREAD_MARK = Object.freeze({ skip: 'sometimes', marks: [], open: true, unread: true, fixtures: [], fixturesOpen: false });
+    const keywordOf = (call, name) => {
+        const args = call.childForFieldName('arguments');
+        for (const argument of args ? args.namedChildren : []) {
+            if (argument.type !== 'keyword_argument') continue;
+            const key = argument.childForFieldName('name');
+            if (key && key.text === name) return argument.childForFieldName('value');
+        }
+        return null;
+    };
+    const positional = call => {
+        const args = call.childForFieldName('arguments');
+        return (args ? args.namedChildren : []).filter(argument => argument.type !== 'keyword_argument' && argument.type !== 'comment');
+    };
+    const mentionsMarks = node => (node.type === 'keyword_argument' && node.childForFieldName('name')?.text === 'marks') ||
+        node.namedChildren.some(mentionsMarks);
+    const plainMark = (name, extra = {}) => ({ skip: null, marks: [name], open: false, fixtures: [], fixturesOpen: false, ...extra });
+    /** What one decorator, or one value of pytestmark, is. */
+    const readMark = (expression, depth = 0) => {
+        if (!expression) return UNREAD_MARK;
+        const call = expression.type === 'call' ? expression : null;
+        const written = dotted(call ? call.childForFieldName('function') : expression);
+        if (!written) {
+            // pytest.mark.skip(reason=...)(function): a call of a call.
+            return call && depth < 4 ? readMark(call.childForFieldName('function'), depth + 1) : UNREAD_MARK;
+        }
+        const path = imported.has(written.split('.')[0]) ? pathOf(written) : null;
+        if (path) {
+            const mark = /^pytest\.mark\.(\w+)$/.exec(path);
+            if (mark) {
+                if (mark[1] === 'skip') return plainMark('skip', { skip: 'skip' });
+                if (mark[1] === 'skipif') return plainMark('skipif', { skip: 'sometimes' });
+                if (mark[1] === 'xfail') {
+                    // run=False leaves the body out where the mark applies:
+                    // always without a condition, else where one is true.
+                    const run = call ? keywordOf(call, 'run') : null;
+                    const truth = run ? truthOf(run) : true;
+                    if (truth === true) return plainMark('xfail');
+                    const conditions = call ? [...positional(call), keywordOf(call, 'condition')].filter(Boolean) : [];
+                    // A condition written as text is evaluated by pytest.
+                    const held = conditions.map(condition => stringOf(condition) != null ? null : truthOf(condition));
+                    const applies = conditions.length === 0 || held.includes(true) ? true : held.every(each => each === false) ? false : null;
+                    return plainMark('xfail', {
+                        skip: applies === false ? null : truth === false && applies === true ? 'skip' : 'sometimes',
+                    });
+                }
+                if (mark[1] === 'parametrize') {
+                    // No value to run with: pytest skips the test. A list
+                    // that is not written out may be empty.
+                    // A row carries its own marks: one that runs the body
+                    // has to be in view.
+                    const given = call ? keywordOf(call, 'argvalues') || positional(call)[1] : null;
+                    const values = sequenceOf(given);
+                    const table = !call || !given || !values ? { skip: 'sometimes' } : tableState(values);
+                    return plainMark('parametrize', {
+                        skip: table.skip, open: !!call && mentionsMarks(call),
+                        ...(table.table && { tables: [table.table] }),
+                    });
+                }
+                if (mark[1] === 'usefixtures') {
+                    const names = call ? positional(call).map(stringOf) : [];
+                    return plainMark('usefixtures', {
+                        fixtures: names.filter(name => name != null),
+                        fixturesOpen: !call ? false : names.some(name => name == null),
+                    });
+                }
+                return plainMark(mark[1]);
+            }
+            if (PY_FIXTURE_PATHS.has(path)) return { ...NOTHING, fixture: true };
+            if (path === 'unittest.skip') return { ...NOTHING, skip: 'skip' };
+            if (path === 'unittest.skipIf' || path === 'unittest.skipUnless') return { ...NOTHING, skip: 'sometimes' };
+            if (path === 'unittest.expectedFailure') return NOTHING;
+            if (/^unittest\.mock\.patch(\.(object|dict|multiple))?$/.test(path)) return NOTHING;
+            if (PY_ABSTRACT_PATHS.has(path) || path === 'functools.wraps' || path === 'typing.override' ||
+                path === 'typing_extensions.override') return NOTHING;
+            return UNREAD_MARK;
+        }
+        if ((written === 'staticmethod' || written === 'classmethod' || written === 'property') &&
+            writesOf('module', written).length === 0) {
+            return NOTHING;
+        }
+        // A name of this module bound once, to one of pytest's marks.
+        const write = written.includes('.') ? null : settled('module', written);
+        if (write && write.kind === 'assign' && depth < 4) {
+            const inner = readMark(write.value, depth + 1);
+            if (!inner.unread && !inner.fixture) return inner;
+        }
+        return UNREAD_MARK;
+    };
+    const combine = parts => ({
+        skip: parts.some(part => part.skip === 'skip') ? 'skip' : parts.some(part => part.skip === 'sometimes') ? 'sometimes' : null,
+        marks: [...new Set(parts.flatMap(part => part.marks))],
+        open: parts.some(part => part.open),
+        fixtures: [...new Set(parts.flatMap(part => part.fixtures || []))],
+        fixturesOpen: parts.some(part => part.fixturesOpen),
+        ...(parts.some(part => part.fixture) && { fixture: true }),
+        ...(parts.some(part => part.tables) && { tables: parts.flatMap(part => part.tables || []) }),
+    });
+    const marksOfValue = node => {
+        if (!node) return UNREAD_MARK;
+        if (node.type === 'list' || node.type === 'tuple' || node.type === 'parenthesized_expression') {
+            return combine(node.namedChildren.map(marksOfValue));
+        }
+        return readMark(node);
+    };
+    /** What pytestmark is in a scope once it has run. */
+    const marksOf = scope => {
+        const candidates = candidatesOf(writesOf(scope, 'pytestmark'));
+        if (candidates.length === 0) return NOTHING;
+        if (candidates.length === 1 && candidates[0] && candidates[0].kind === 'assign') return marksOfValue(candidates[0].value);
+        const parts = candidates.map(write => write && write.kind === 'assign' ? marksOfValue(write.value) : NOTHING);
+        return { ...combine(parts), skip: 'sometimes', open: true, fixturesOpen: true };
+    };
+    const decoratorsOf = info => {
+        const holder = info && info.node.parent && info.node.parent.type === 'decorated_definition' ? info.node.parent : null;
+        return (holder ? holder.namedChildren : []).filter(child => child.type === 'decorator').map(child => child.namedChildren[0]);
+    };
+    const decoratedMemo = new Map();
+    const decoratedOf = info => {
+        if (!info) return NOTHING;
+        if (!decoratedMemo.has(info)) decoratedMemo.set(info, combine(decoratorsOf(info).map(expression => readMark(expression))));
+        return decoratedMemo.get(info);
+    };
+    const settledModuleMarks = marksOf('module');
+    const moduleMarks = marksUnsettled
+        ? { ...settledModuleMarks, skip: settledModuleMarks.skip || 'sometimes', open: true, fixturesOpen: true }
+        : settledModuleMarks;
+
+    // ---- code that can stop a test before its body ----
+    const stopMemo = new Map();
+    const NO_STOP = Object.freeze({ stops: false, calls: [] });
+    /**
+     * Can running a function stop a test: it mentions a stopping name,
+     * raises, or calls a function of the module that can. `calls`: the
+     * functions of other modules of the project it calls; whether one of
+     * those can is said where the files are put together.
+     */
+    const stopFacts = (fn, raises = true) => {
+        const key = `${fn.id}${raises ? '' : ' skips'}`;
+        if (stopMemo.has(key)) return stopMemo.get(key);
+        stopMemo.set(key, NO_STOP);
+        const body = fn.childForFieldName('body');
+        const calls = [];
+        const answer = { stops: !!body && stops(body, calls, raises), calls };
+        stopMemo.set(key, answer);
+        return answer;
+    };
+    const mayStop = fn => stopFacts(fn).stops;
+    // For a caller in another module: a function that names a skip. One
+    // that only raises reports an error of its own, as any function may.
+    const maySkip = fn => stopFacts(fn, false).stops;
+    /** The function of another module of the project a callee names, or null. */
+    const projectCall = callee => {
+        const written = dotted(callee);
+        if (!written) return null;
+        const parts = written.split('.');
+        const binding = imported.get(parts[0]);
+        if (!binding) return null;
+        if (binding.kind === 'import') {
+            // module.function, by the module's own name or the one it is imported as
+            if (parts.length !== 2 || !inProject(binding.module)) return null;
+            return { module: binding.module, name: parts[1] };
+        }
+        // A function taken by name; or a module taken by name from its
+        // package (from tests import helpers; helpers.need()).
+        if (!inProject(binding.module)) return null;
+        if (parts.length === 1) return { module: binding.module, name: binding.name };
+        if (parts.length !== 2 || binding.kind !== 'from') return null;
+        return { module: `${binding.module}.${binding.name}`, name: parts[1] };
+    };
+    const stops = (node, calls = [], raises = true) => {
+        switch (node.type) {
+            // A bare raise hands on what was already raised.
+            case 'raise_statement':
+                if (raises) return node.namedChildren.length > 0;
+                break;
+            case 'identifier': {
+                if (PY_STOPPING_NAMES.has(node.text)) return true;
+                const binding = imported.get(node.text);
+                if (binding && binding.kind !== 'import' && PY_STOPPING_NAMES.has(binding.name)) return true;
+                const path = pathOf(node.text);
+                return !!path && PY_STOPPING_PATHS.test(path);
+            }
+            case 'attribute': {
+                const written = dotted(node);
+                const path = written ? pathOf(written) : null;
+                // pytest.mark.skip is a mark: it is read where it is applied.
+                if (path && /^pytest\.mark(\.|$)/.test(path)) return false;
+                if (path && PY_STOPPING_PATHS.test(path)) return true;
+                const name = node.childForFieldName('attribute');
+                if (name && PY_STOPPING_NAMES.has(name.text)) return true;
+                return stops(node.childForFieldName('object'), calls, raises);
+            }
+            case 'string_content': return PY_STOPPING_NAMES.has(node.text);
+            case 'call': {
+                const callee = node.childForFieldName('function');
+                if (callee && callee.type === 'identifier' && !imported.has(callee.text)) {
+                    for (const fn of functionsNamed.get(callee.text) || []) {
+                        const facts = stopFacts(fn, raises);
+                        if (facts.stops) return true;
+                        calls.push(...facts.calls);
+                    }
+                }
+                const elsewhere = projectCall(callee);
+                if (elsewhere) calls.push(elsewhere);
+                break;
+            }
+            default: break;
+        }
+        return node.namedChildren.some(child => stops(child, calls, raises));
+    };
+    /**
+     * Can a hook change what is collected or run: it can stop a test, it
+     * yields (it wraps the step), it returns a value where the value
+     * decides, or it uses what pytest hands it in a way that is none of
+     * the calls that only read.
+     */
+    const hookDecides = fn => {
+        if (mayStop(fn)) return true;
+        const body = fn.childForFieldName('body');
+        if (!body) return true;
+        const hookName = fn.childForFieldName('name').text;
+        const wraps = node => node.type === 'yield' ||
+            (node.type === 'return_statement' && !PYTEST_REPORTING_HOOKS.has(hookName) &&
+                !!node.namedChildren[0] && node.namedChildren[0].type !== 'none') ||
+            node.namedChildren.some(wraps);
+        if (wraps(body)) return true;
+        const handed = new Set(parameterNames(fn));
+        if (handed.size === 0) return false;
+        const isReference = node => {
+            const parent = node.parent;
+            if (!parent) return true;
+            if (parent.type === 'attribute' && sameNode(parent.childForFieldName('attribute'), node)) return false;
+            if (parent.type === 'keyword_argument' && sameNode(parent.childForFieldName('name'), node)) return false;
+            // The name bound again: nothing is done to what it held.
+            if (parent.type === 'assignment' && sameNode(parent.childForFieldName('left'), node)) return false;
+            return true;
+        };
+        // What one use of a handed object is: false when it can change
+        // something, else what the use makes of it.
+        const useOf = reference => {
+            let top = reference;
+            for (;;) {
+                while (top.parent && top.parent.type === 'attribute' && sameNode(top.parent.childForFieldName('object'), top)) top = top.parent;
+                const call = top.parent;
+                if (top.type !== 'attribute' || !call || call.type !== 'call' || !sameNode(call.childForFieldName('function'), top)) return false;
+                const method = top.childForFieldName('attribute').text;
+                if (!PYTEST_HOOK_READS.has(method)) return false;
+                if (method === 'addinivalue_line') {
+                    const key = stringOf(positional(call)[0]);
+                    if (key !== 'markers' && key !== 'filterwarnings') return false;
+                }
+                if (!PYTEST_HOOK_OBJECTS.has(method)) return {};
+                const holder = call.parent;
+                if (holder && holder.type === 'attribute' && sameNode(holder.childForFieldName('object'), call)) {
+                    top = call;
+                    continue;
+                }
+                if (holder && holder.type === 'assignment' && sameNode(holder.childForFieldName('right'), call)) {
+                    const left = holder.childForFieldName('left');
+                    return left && left.type === 'identifier' ? { hands: left.text } : false;
+                }
+                return holder && PY_TRUTH_TESTS.has(holder.type) ? {} : false;
+            }
+        };
+        let decides = false;
+        let grew = true;
+        const visit = node => {
+            if (decides) return;
+            if (node.type === 'identifier' && handed.has(node.text) && isReference(node)) {
+                const use = useOf(node);
+                if (use === false) decides = true;
+                else if (use.hands && !handed.has(use.hands)) {
+                    handed.add(use.hands);
+                    grew = true;
+                }
+                return;
+            }
+            for (const child of node.namedChildren) visit(child);
+        };
+        while (grew && !decides) {
+            grew = false;
+            visit(body);
+        }
+        return decides;
+    };
+    /** The fixture a definition is, or null: its name, whether every test gets it, whether it can stop one. */
+    const fixtureOf = info => {
+        if (!info || info.node.type !== 'function_definition') return null;
+        let made = null;
+        for (const expression of decoratorsOf(info)) {
+            const call = expression.type === 'call' ? expression : null;
+            const written = dotted(call ? call.childForFieldName('function') : expression);
+            const path = written ? pathOf(written) : null;
+            if (path && PY_FIXTURE_PATHS.has(path)) made = { call };
+        }
+        if (!made) return null;
+        const call = made.call;
+        const functionName = info.node.childForFieldName('name').text;
+        const renamed = call ? keywordOf(call, 'name') : null;
+        const autouse = call ? keywordOf(call, 'autouse') : null;
+        const params = call ? keywordOf(call, 'params') : null;
+        const values = params ? sequenceOf(params) : null;
+        // No row that runs the body in view: a list that is not written
+        // out, an empty one, rows whose own marks skip.
+        const table = !params ? NO_TABLE : !values ? { skip: 'sometimes' } : tableState(values);
+        return {
+            name: renamed ? stringOf(renamed) : functionName,
+            function: functionName,
+            // A value that is not written out may be true.
+            autouse: !!autouse && truthOf(autouse) !== false,
+            decides: mayStop(info.node) || table.skip != null || (!!renamed && stringOf(renamed) == null),
+            ...(table.table && { tables: [table.table] }),
+            // A test that asks for it runs once for every parameter.
+            ...(params && { params: true }),
+            ...(stopFacts(info.node).calls.length > 0 && { calls: stopFacts(info.node).calls }),
+            requests: parameterNames(info.node),
+        };
+    };
+
+    // ---- what runs when the module is imported ----
+    let moduleSkips = false;
+    let namespaceWritten = false;
+    const importTimeCalls = []; // functions of other modules of the project called when this one is imported
+    const isMainTest = condition => !!condition && condition.type === 'comparison_operator' &&
+        condition.namedChildren.length === 2 && condition.children.some(child => child.type === '==') &&
+        condition.namedChildren.some(child => child.type === 'identifier' && child.text === '__name__') &&
+        condition.namedChildren.some(child => stringOf(child) === '__main__');
+    const importTime = node => {
+        switch (node.type) {
+            // Bodies run when called; decorators are read with the definition.
+            case 'function_definition': case 'lambda': case 'import_statement': case 'import_from_statement':
+            case 'decorator':
+                return;
+            case 'class_definition': {
+                const body = node.childForFieldName('body');
+                for (const child of body ? body.namedChildren : []) importTime(child);
+                return;
+            }
+            case 'if_statement':
+                // pytest never imports a module under the name __main__.
+                if (isMainTest(node.childForFieldName('condition'))) {
+                    for (const child of node.namedChildren) {
+                        if (child.type === 'elif_clause' || child.type === 'else_clause') importTime(child);
+                    }
+                    return;
+                }
+                break;
+            case 'raise_statement':
+                if (node.namedChildren.length > 0) moduleSkips = true;
+                return;
+            case 'identifier': {
+                if (PY_NAMESPACE_NAMES.has(node.text)) namespaceWritten = true;
+                const path = pathOf(node.text);
+                if (path && PY_STOPPING_PATHS.test(path)) moduleSkips = true;
+                return;
+            }
+            case 'attribute': {
+                const written = dotted(node);
+                const path = written ? pathOf(written) : null;
+                if (path && /^pytest\.mark(\.|$)/.test(path)) return;
+                if (path && PY_STOPPING_PATHS.test(path)) {
+                    moduleSkips = true;
+                    return;
+                }
+                const name = node.childForFieldName('attribute');
+                if (name && PY_NAMESPACE_NAMES.has(name.text)) namespaceWritten = true;
+                importTime(node.childForFieldName('object'));
+                return;
+            }
+            case 'call': {
+                const callee = node.childForFieldName('function');
+                if (callee && callee.type === 'identifier' && !imported.has(callee.text)) {
+                    for (const fn of functionsNamed.get(callee.text) || []) {
+                        if (mayStop(fn)) moduleSkips = true;
+                        importTimeCalls.push(...stopFacts(fn).calls);
+                    }
+                }
+                const elsewhere = projectCall(callee);
+                if (elsewhere) importTimeCalls.push(elsewhere);
+                break;
+            }
+            default: break;
+        }
+        for (const child of node.namedChildren) importTime(child);
+    };
+    importTime(root);
+
+    // ---- what a definition is once its scope has run ----
+    const infoOf = symbol => definitions.get((symbol.nameLine || symbol.startLine) - 1) ||
+        definitions.get(symbol.startLine - 1) || null;
+    const mentions = (node, name) => !!node && ((node.type === 'identifier' && node.text === name) ||
+        node.namedChildren.some(child => mentions(child, name)));
+    // 'definite': the name holds this definition. 'maybe': it may (a
+    // branch, a later write that wraps it). 'gone': it does not.
+    const stateOf = (info, name) => {
+        if (!info) return 'gone';
+        const candidates = candidatesOf(writesOf(info.scope, name));
+        const mine = candidates.some(write => write && write.pos === info.pos);
+        if (mine) return candidates.length === 1 ? 'definite' : 'maybe';
+        return candidates.every(write => write && write.kind === 'assign' && mentions(write.value, name)) ? 'maybe' : 'gone';
+    };
+    /**
+     * A function as a test, by what it is itself: its definition, its
+     * decorators, a switch written on it. Null: no test (gone, a fixture).
+     * One switched off stays (`off`): the switch is the state of an object
+     * that another module may hold under another name and write again.
+     */
+    const rowOf = symbol => {
+        const info = infoOf(symbol);
+        const state = stateOf(info, symbol.name);
+        if (state === 'gone') return null;
+        const own = decoratedOf(info);
+        if (own.fixture) return null;
+        const written = attributeSwitch(info.scope, symbol.name);
+        const dynamic = state === 'maybe' ? 'defined-conditionally'
+            : (switchUnsettled || (written && written.on === 'unknown')) ? 'collection-switch' : null;
+        return {
+            name: symbol.name, line: symbol.nameLine || symbol.startLine, startLine: symbol.startLine,
+            endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
+            named: functionNamed(symbol.name), prefixed: symbol.name.startsWith('test'),
+            // (Where a switch of the file is not read, off is not settled either.)
+            ...(written && written.on === false && !switchUnsettled && { off: true }),
+            ...(written && written.forced && { forced: written.forced }),
+            ...(own.tables && { tables: own.tables }),
+            ...(own.skip === 'skip' && { skipped: true }),
+            ...((own.skip === 'sometimes' || dynamic) && { conditional: true }),
+            ...(dynamic && { dynamic }),
+            marks: own.marks, marksOpen: own.open,
+            requests: [...new Set([...parameterNames(info.node), ...own.fixtures])],
+            ...(own.fixturesOpen && { requestsOpen: true }),
+        };
+    };
+    /** Is a name bound to something this does not list that could be a test? */
+    const boundToMore = writes => candidatesOf(writes).some(write => write && (write.kind === 'other' || write.kind === 'augment' ||
+        (write.kind === 'assign' && !PY_PLAIN_VALUES.has(unwrapped(write.value).type))));
+    let more = namespaceWritten || switchUnsettled;
+
+    // ---- the module's own functions, other names for them, lambdas ----
+    const moduleSwitch = switchUnsettled ? OPEN_SWITCH : switchValue(writesOf('module', '__test__'));
+    const moduleOff = !!moduleSwitch && moduleSwitch.on === false;
+    const units = [];
+    const functions = [];
+    const imports = [];
+    for (const symbol of symbols) {
+        if (!helpers.isCallable(symbol) || symbol.type === 'constructor') continue;
+        if (helpers.enclosing(symbol).length > 0) continue;
+        const info = infoOf(symbol);
+        if (!info || info.scope !== 'module') continue;
+        const row = rowOf(symbol);
+        if (!row) continue;
+        functions.push(row);
+        if ((row.named || row.forced) && !row.off) units.push({ kind: 'test', suite: [], ...row });
+    }
+    for (const [name, writes] of scopeWrites.get('module') || []) {
+        const write = settled('module', name);
+        const value = write && write.kind === 'assign' ? unwrapped(write.value) : null;
+        if (value && value.type === 'identifier' && value.text !== name) {
+            // Another name for something the module holds.
+            imports.push({ name, original: value.text, module: null, line: write.line });
+            continue;
+        }
+        if (value && value.type === 'lambda' && !functions.some(other => other.name === name)) {
+            const row = {
+                name, line: write.line, startLine: write.line, endLine: write.endLine,
+                named: functionNamed(name), prefixed: name.startsWith('test'), marks: [], marksOpen: false,
+                requests: parameterNames(value),
+            };
+            functions.push(row);
+            if (row.named) units.push({ kind: 'test', suite: [], ...row });
+            continue;
+        }
+        if ((functionNamed(name) || classNamed(name)) && boundToMore(writes)) more = true;
+    }
+    // Names taken from other modules that the module still holds when it
+    // has run: a test class or function among them is collected here.
+    for (const binding of fileEntry.importBindings || []) {
+        if (binding.kind === 'import') continue;
+        const bound = binding.alias || binding.name;
+        const write = settled('module', bound);
+        if (!write || write.kind !== 'import' || write.line !== binding.line) continue;
+        imports.push({ name: bound, original: binding.name, module: binding.module, line: binding.line });
+    }
+
+    // ---- classes ----
+    const classInfo = cls => infoOf(cls);
+    const classes = [];
+    const eligibleMemo = new Map();
+    // Its definition is there, and so is every class around it.
+    const eligible = cls => {
+        if (!eligibleMemo.has(cls)) {
+            eligibleMemo.set(cls, false);
+            eligibleMemo.set(cls, stateOf(classInfo(cls), cls.name) !== 'gone' &&
+                helpers.enclosing(cls).every(outer => outer.type === 'class' && eligible(outer)));
+        }
+        return eligibleMemo.get(cls);
+    };
+    for (const cls of symbols) {
+        if (cls.type !== 'class') continue;
+        const chain = helpers.enclosing(cls);
+        if (chain.some(outer => outer.type !== 'class') || !eligible(cls)) continue;
+        const info = classInfo(cls);
+        const scope = info.node.id;
+        // A base is looked up by the name it was declared under.
+        const written = basesOf(cls).map(base => ({ base, from: origin(base) }));
+        const declaredHere = name => symbols.some(symbol => symbol.type === 'class' && symbol.name === name) ||
+            writesOf('module', name).length > 0;
+        // A class of unittest, or (taken as one) a class from outside the
+        // project that is named like one: neither brings a test.
+        const outsideCase = ({ base, from }) => /TestCase$/.test(from.name) &&
+            (from.bound ? !inProject(from.module) : !declaredHere(base.split('.')[0]));
+        const ownMarks = combine([decoratedOf(info), marksOf(scope)]);
+        const ownSwitch = switchUnsettled ? OPEN_SWITCH
+            : switchValue([...writesOf(scope, '__test__'), ...(attributeWrites.get(`${info.scope}\0${cls.name}`) || [])]);
+        const superclasses = info.node.childForFieldName('superclasses');
+        const metaclass = (superclasses ? superclasses.namedChildren : [])
+            .find(argument => argument.type === 'keyword_argument' && argument.childForFieldName('name')?.text === 'metaclass');
+        const metaPath = metaclass ? pathOf(dotted(metaclass.childForFieldName('value')) || '') : null;
+        const members = new Set(symbols.filter(symbol => holds(cls, symbol)).map(symbol => symbol.name));
+        for (const name of (scopeWrites.get(scope) || new Map()).keys()) members.add(name);
+        const tests = [];
+        const abstract = [];
+        const fixtures = [];
+        const guardCalls = [];
+        let guard = false;
+        let generates = false;
+        // What the class body leaves under a constructor's name: 'custom'
+        // (a function of its own: pytest refuses the class), 'object' (the
+        // builtin's, written back), 'unknown'. Undefined: the body binds
+        // none and the next class in the lookup order decides.
+        const constructorOf = name => {
+            if (info.scope === 'module' && constructorWrites.has(cls.name)) return 'unknown';
+            const kinds = candidatesOf(writesOf(scope, name)).map(write => {
+                if (write === null || write.kind === 'del') return 'absent';
+                if (write.kind === 'def') return 'custom';
+                const value = write.kind === 'assign' ? dotted(unwrapped(write.value)) : null;
+                return value === `object.${name}` && !imported.has('object') && writesOf('module', 'object').length === 0 &&
+                    stars.length === 0 ? 'object' : 'unknown';
+            });
+            if (kinds.every(kind => kind === 'absent')) return undefined;
+            return kinds.every(kind => kind === kinds[0]) ? kinds[0] : 'unknown';
+        };
+        const constructs = {};
+        for (const name of PYTHON_CONSTRUCTORS) {
+            const kind = constructorOf(name);
+            if (kind) constructs[name] = kind;
+        }
+        // typing.Protocol gives every class that lists it a constructor
+        // of its own (measured: pytest refuses the class and what derives from it).
+        if (written.some(entry => /^Protocol(\[|$)/.test(entry.from.name) &&
+            (entry.from.bound ? /^typing(_extensions)?$/.test(entry.from.module) : !declaredHere(entry.base.split('.')[0].replace(/\[.*$/, ''))))) {
+            constructs.__init__ = 'custom';
+        }
+        for (const symbol of symbols) {
+            if (!holds(cls, symbol) || !helpers.isCallable(symbol)) continue;
+            const memberInfo = infoOf(symbol);
+            if (!memberInfo || memberInfo.scope !== scope) continue;
+            // pytest calls a class's own pytest_generate_tests for its tests.
+            if (symbol.name === 'pytest_generate_tests' && stateOf(memberInfo, symbol.name) !== 'gone') generates = true;
+            if (decoratorsOf(memberInfo).some(expression => {
+                const path = pathOf(dotted(expression.type === 'call' ? expression.childForFieldName('function') : expression) || '');
+                return !!path && PY_ABSTRACT_PATHS.has(path);
+            })) abstract.push(symbol.name);
+            const fixture = fixtureOf(memberInfo);
+            if (fixture) {
+                fixtures.push(fixture);
+                if (fixture.autouse && fixture.decides) guard = true;
+                if (fixture.autouse) guardCalls.push(...(fixture.calls || []));
+                continue;
+            }
+            if (PY_CLASS_SETUPS.has(symbol.name) && stateOf(memberInfo, symbol.name) !== 'gone') {
+                if (mayStop(memberInfo.node)) guard = true;
+                guardCalls.push(...stopFacts(memberInfo.node).calls);
+            }
+            if (symbol.type === 'constructor') continue;
+            const row = rowOf(symbol);
+            if (!row) continue;
+            // A member switched off is no test of the class or of one
+            // deriving from it (`off`): it stays, for its name hides the
+            // one further up and a module that takes the class may write
+            // the switch again.
+            if (row.named || row.prefixed || row.forced || symbol.name === 'runTest') tests.push(row);
+        }
+        // Another name for a test of the class is one more test.
+        for (const [name, writes] of scopeWrites.get(scope) || []) {
+            const write = settled(scope, name);
+            const value = write && write.kind === 'assign' ? unwrapped(write.value) : null;
+            const target = value && value.type === 'identifier' && value.text !== name
+                ? tests.find(row => row.name === value.text && !row.alias && !row.off) : null;
+            if (target && settled(scope, value.text) && settled(scope, value.text).kind === 'def') {
+                tests.push({
+                    ...target, name, line: write.line, of: target.line, alias: true,
+                    named: functionNamed(name), prefixed: name.startsWith('test'),
+                });
+            } else if ((functionNamed(name) || name.startsWith('test') || classNamed(name)) && boundToMore(writes)) {
+                more = true;
+            }
+        }
+        classes.push({
+            name: cls.name, suite: chain.map(outer => outer.name), bases: written.map(entry => entry.from.name),
+            // Bases known to bring neither a constructor nor a test.
+            plainBases: written.filter(entry => PYTHON_PLAIN_BASES.has(entry.from.name) ||
+                entry.from.module === 'unittest' || (entry.from.module === null && /^unittest\./.test(entry.base)) ||
+                outsideCase(entry)).map(entry => entry.from.name),
+            named: classNamed(cls.name),
+            ...(written.some(entry => (entry.from.module === 'unittest' && /TestCase$/.test(entry.from.name)) ||
+                (entry.from.module === null && /^unittest\.\w*TestCase$/.test(entry.base)) || outsideCase(entry)) && { unittestBase: true }),
+            // pytest does not collect a class whose constructor, by its
+            // lookup order, is not object's; unittest's classes are built
+            // by unittest.
+            ...(Object.keys(constructs).length > 0 && { constructs }),
+            ...(generates && { generates: true }),
+            ...(ownMarks.tables && { tables: ownMarks.tables }),
+            ...(ownSwitch && { enabled: ownSwitch.on }),
+            ...(ownSwitch && ownSwitch.forced && { forced: ownSwitch.forced }),
+            ...(stateOf(info, cls.name) === 'maybe' && { unsettled: true }),
+            ...(ownMarks.skip && { skip: ownMarks.skip }),
+            ...(guard && { guard: true }),
+            ...(guardCalls.length > 0 && { guardCalls }),
+            ...(fixtures.length > 0 && { fixtures }),
+            ...(ownMarks.fixtures.length > 0 && { usefixtures: ownMarks.fixtures }),
+            ...(ownMarks.fixturesOpen && { usefixturesOpen: true }),
+            ...(abstract.length > 0 && { abstract }),
+            ...((written.some(entry => entry.from.module === 'abc' && entry.from.name === 'ABC') || metaPath === 'abc.ABCMeta')
+                ? { abc: true } : metaclass ? { abc: 'unknown' } : {}),
+            marks: ownMarks.marks, marksOpen: ownMarks.open,
+            line: cls.nameLine || cls.startLine, startLine: cls.startLine, endLine: cls.endLine ?? cls.startLine, sourceSpan: cls.sourceSpan,
+            members: [...members], tests,
+        });
+    }
+
+    // ---- what the file does as a plugin (a conftest.py, a module named by pytest_plugins) ----
+    const moduleFixtures = [];
+    const moduleGuardCalls = [];
+    const hookCalls = []; // functions of other modules of the project its hooks call
+    const stopping = []; // functions of the module's top that name a skip: they stop a test of a module that calls them
+    let hooksDecide = false;
+    let hooksEverywhere = false;
+    let generates = false;
+    let moduleGuard = false;
+    for (const info of definitions.values()) {
+        if (info.scope !== 'module' || info.node.type !== 'function_definition') continue;
+        const name = info.node.childForFieldName('name').text;
+        if (stateOf(info, name) === 'gone') continue;
+        if (maySkip(info.node)) stopping.push(name);
+        const fixture = fixtureOf(info);
+        if (fixture) {
+            moduleFixtures.push(fixture);
+            if (fixture.autouse) moduleGuardCalls.push(...(fixture.calls || []));
+            continue;
+        }
+        if (/^pytest_/.test(name) && hookDecides(info.node)) {
+            hooksDecide = true;
+            if (!PYTEST_NODE_HOOKS.has(name)) hooksEverywhere = true;
+            // The one hook pytest also calls in a test module.
+            if (name === 'pytest_generate_tests') generates = true;
+        } else if (/^pytest_/.test(name)) {
+            // A hook that decides nothing itself may call a function of
+            // another module of the project that does.
+            for (const call of stopFacts(info.node).calls) {
+                hookCalls.push({
+                    ...call,
+                    ...(!PYTEST_NODE_HOOKS.has(name) && { everywhere: true }),
+                    ...(name === 'pytest_generate_tests' && { generates: true }),
+                });
+            }
+        }
+        if (PY_MODULE_SETUPS.has(name)) {
+            if (mayStop(info.node)) moduleGuard = true;
+            moduleGuardCalls.push(...stopFacts(info.node).calls);
+        }
+    }
+    const plugins = stars.map(star => ({ module: star.module, by: 'import' }));
+    for (const [name, writes] of scopeWrites.get('module') || []) {
+        if (!/^pytest_/.test(name)) continue;
+        if (name === 'pytest_plugins') {
+            // The modules named are loaded as plugins.
+            const write = settled('module', name);
+            const value = write && write.kind === 'assign' ? unwrapped(write.value) : null;
+            const names = !value ? null : stringOf(value) != null ? [stringOf(value)]
+                : (value.type === 'list' || value.type === 'tuple')
+                    ? value.namedChildren.filter(item => item.type !== 'comment').map(stringOf) : null;
+            if (!names || names.some(each => each == null)) {
+                hooksDecide = true;
+                hooksEverywhere = true;
+            } else {
+                for (const each of names) plugins.push({ module: each, by: 'name' });
+            }
+            continue;
+        }
+        // A hook bound by anything but its own definition is not read.
+        if (writes.some(write => write.kind !== 'def')) {
+            hooksDecide = true;
+            if (!PYTEST_NODE_HOOKS.has(name)) hooksEverywhere = true;
+            if (name === 'pytest_generate_tests') generates = true;
+        }
+    }
+    // What a star import brings: the names __all__ lists when it is
+    // written out, every public name otherwise.
+    const allWrites = writesOf('module', '__all__');
+    const allWrite = settled('module', '__all__');
+    const allValue = allWrite && allWrite.kind === 'assign' ? unwrapped(allWrite.value) : null;
+    const allNames = allValue && (allValue.type === 'list' || allValue.type === 'tuple')
+        ? allValue.namedChildren.filter(item => item.type !== 'comment').map(stringOf) : null;
+    const exportsAll = allWrites.length === 0 ? null
+        : allNames && allNames.every(name => name != null) && allWrites.length === 1 ? allNames : 'unknown';
+
+    const takenConstructors = [...constructorWrites].filter(name => imported.has(name) || starBound('module', name));
+    /**
+     * What a name of this module is as a row of parameters, for a module
+     * that takes it: `member` of a class the name holds, `call` for what
+     * calling it gives back. Null: the module does not bind the name.
+     * { via }: it is what a name of another module is, to be read there;
+     * { stars }: one of the modules this one takes every name of binds it.
+     */
+    const rowNamed = (name, member = null, call = false, depth = 0) => {
+        if (depth > 4 || classWritten.has(name)) return 'sometimes';
+        if (writesOf('module', name).length === 0) {
+            if (namespaceWritten) return 'sometimes';
+            return stars.length > 0 ? { stars: stars.map(star => star.module) } : null;
+        }
+        const top = settled('module', name);
+        if (!top) return 'sometimes';
+        if (top.kind === 'import') {
+            const binding = imported.get(name);
+            if (!binding) return 'sometimes';
+            // A module taken whole is a plain row; a name of it is read in it.
+            if (binding.kind === 'import') {
+                return member ? { via: { module: binding.module, name: member, call } } : call ? 'sometimes' : RUN;
+            }
+            return { via: { module: binding.module, name: binding.name, ...(member && { member }), call } };
+        }
+        if (top.kind === 'assign') {
+            // Another name for something of the module is what that is.
+            const value = unwrapped(top.value);
+            if (value && value.type === 'identifier' && value.text !== name) return rowNamed(value.text, member, call, depth + 1);
+            return member || call ? 'sometimes' : rowState(top.value, 1);
+        }
+        if (member) {
+            if (top.kind !== 'class' || call) return 'sometimes';
+            const members = candidatesOf(writesOf(top.node.id, member));
+            return members.length === 0 ? 'sometimes' : writeState(members, 0);
+        }
+        if (top.kind === 'class') return RUN;
+        if (top.kind === 'def') return call && makesRows(top.node) ? 'sometimes' : RUN;
+        return 'sometimes';
+    };
+    const collected = collection.collected !== false;
+    return {
+        derived: true,
+        rowNamed,
+        // A switch written in a way that is not read: which of the names
+        // the module holds it turned on or off is not settled.
+        ...(switchUnsettled && { switchesOpen: true }),
+        units: collected ? units : [],
+        classes, functions, imports, stars, exportsAll, linearization: 'c3',
+        // The members whose lookup decides whether pytest takes a class.
+        constructors: PYTHON_CONSTRUCTORS,
+        module: {
+            ...(moduleMarks.skip || moduleSkips ? { skip: moduleMarks.skip === 'skip' ? 'skip' : 'sometimes' } : {}),
+            ...(moduleSwitch && moduleSwitch.on === 'unknown' && { unsettled: true }),
+            ...((moduleGuard || moduleFixtures.some(fixture => fixture.autouse && fixture.decides) || generates) && { guard: true }),
+            ...(moduleMarks.fixtures.length > 0 && { usefixtures: moduleMarks.fixtures }),
+            ...(moduleMarks.fixturesOpen && { usefixturesOpen: true }),
+            // Functions of other modules of the project called when the
+            // module is imported, and by its setups: one that can stop a
+            // test makes its tests conditional.
+            ...(importTimeCalls.length > 0 && { skipCalls: importTimeCalls }),
+            ...(moduleGuardCalls.length > 0 && { guardCalls: moduleGuardCalls }),
+            // Switches written here on names taken from other modules.
+            switches: Object.fromEntries([...attributeWrites.keys()].filter(key => key.startsWith('module\0'))
+                .map(key => key.slice('module\0'.length))
+                .filter(name => starBound('module', name) ||
+                    (writesOf('module', name).length === 1 && writesOf('module', name)[0].kind === 'import'))
+                .map(name => [name, switchUnsettled ? OPEN_SWITCH : attributeSwitch('module', name)])),
+            // Names taken from other modules whose constructor is written here.
+            ...(takenConstructors.length > 0 && { constructorWrites: takenConstructors }),
+            ...(moduleMarks.tables && { tables: moduleMarks.tables }),
+        },
+        runtime: {
+            decides: hooksDecide, everywhere: hooksEverywhere, generates, fixtures: moduleFixtures, plugins,
+            ...(hookCalls.length > 0 && { hookCalls }),
+        },
+        stopping: [...new Set(stopping)],
+        marks: moduleMarks.marks, marksOpen: moduleMarks.open,
+        ...(moduleOff && { off: true }),
+        ...(more && collected && { inheriting: true }),
+        ...(!collected && { notCollected: true }),
+    };
+}
+
 /**
  * Classify a Python symbol as a runtime entry point of a specific kind.
  * Returns 'test' | 'framework' | null.
@@ -5847,7 +7343,215 @@ function annotatedReceiverType(tree, line, column, receiver) {
     return typeNameFromAnnotation(parameter.childForFieldName('type')) || undefined;
 }
 
+// The comments the type checker reads as directives (pyright's tokenizer).
+const TYPE_IGNORE = /(^|#)\s*type:\s*ignore(\[[\s\w-,]*\]|\s|$)/;
+const PYRIGHT_IGNORE = /(^|#)\s*pyright:\s*ignore(?:\[([\s\w-,]*)\]|\s|$)/;
+const CHECK_MODES = new Set(['basic', 'standard', 'strict']);
+
+function checkSettingOperands(text) {
+    const value = text.slice(1).trim();
+    if (!value.startsWith('pyright:')) return null;
+    const operands = value.slice('pyright:'.length);
+    return operands.trim().startsWith('ignore') ? null : operands;
+}
+
+/** Use the same ignore grammar for suppression and changed-code context. */
+function checkDirectiveComment(text) {
+    // Ordinary type annotations also affect checking. Keep those even
+    // though they are not suppressions read by checkSuppressedAt.
+    return /^#\s*(?:type|pyright)\s*:/.test(text) ||
+        TYPE_IGNORE.test(text) || PYRIGHT_IGNORE.test(text);
+}
+
+function checkFileDirectiveComment(text) {
+    if (TYPE_IGNORE.test(text)) return 'leading-or-local';
+    if (PYRIGHT_IGNORE.test(text)) return null;
+    return checkSettingOperands(text) !== null ? 'column-zero-file' : null;
+}
+// The rule each kind of break is reported under.
+const RULE_OF = Object.freeze({
+    'arity': 'reportCallIssue',
+    'import-name': 'reportAttributeAccessIssue',
+    'import-module': 'reportMissingImports',
+    'undefined-name': 'reportUndefinedVariable',
+});
+
+/**
+ * What the comments of a file tell the checker:
+ *   all      a `type: ignore` comment before any token: nothing is reported;
+ *   lines    line -> null (everything on it is ignored: `type: ignore`,
+ *            `pyright: ignore`) or the rules a `pyright: ignore[..]` names;
+ *   levels   rule -> level set by `# pyright: rule=level` comments. The
+ *            checker applies them even at an invalid position, reporting
+ *            a separate placement diagnostic; changed-code context tracks
+ *            that column-zero requirement independently.
+ *            `basic`, `standard` and `strict` choose a rule set: none of
+ *            them turns a rule off.
+ */
+function checkDirectives(root) {
+    const ignored = new Map();
+    const levels = new Map();
+    let all = false;
+    const firstToken = root.children.find(child => child.type !== 'comment');
+    const codeStart = firstToken ? firstToken.startIndex : Infinity;
+    for (const comment of root.descendantsOfType('comment')) {
+        const text = comment.text;
+        const line = comment.startPosition.row + 1;
+        if (TYPE_IGNORE.test(text)) {
+            if (comment.startIndex < codeStart) all = true;
+            else ignored.set(line, null);
+        }
+        const scoped = PYRIGHT_IGNORE.exec(text);
+        if (scoped && !(ignored.has(line) && ignored.get(line) === null)) {
+            ignored.set(line, scoped[2] === undefined ? null
+                : scoped[2].split(',').map(rule => rule.trim()).filter(Boolean));
+        }
+        const operands = checkSettingOperands(text);
+        if (operands === null) continue;
+        const list = operands.split(',').map(operand => operand.trim()).filter(Boolean);
+        if (list.some(operand => CHECK_MODES.has(operand))) levels.clear();
+        for (const operand of list) {
+            const [rule, level] = operand.split('=').map(part => part.trim());
+            // A level the checker does not know leaves the rule as it was.
+            if (rule && CHECK_LEVELS.has(level)) levels.set(rule, level);
+        }
+    }
+    return { all, ignored, levels };
+}
+
+// The levels a `# pyright: rule=level` comment may set.
+const CHECK_LEVELS = new Set(['true', 'false', 'error', 'warning', 'information', 'none']);
+
+/** The `call` node that covers exactly `span`, or null. */
+function callAtSpan(root, span) {
+    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 && node.type === 'call') return node;
+        if (node.startIndex < span.start || node.endIndex > span.end) break;
+    }
+    return null;
+}
+
+/**
+ * The ranges the checker reports a break over, one per report it makes: a
+ * comment on any line of a range silences that report, and the break is
+ * silenced when every report is.
+ *   arity           too few arguments: the whole call. One positional
+ *                   argument too many, a keyword the callable does not
+ *                   take or takes twice: that argument;
+ *   import-name     the imported name; import-module: the module name;
+ *   undefined-name  the line itself.
+ * The call is the one the engine measured (`site.span`), whatever name it
+ * is called under and however many calls share its line; an import is the
+ * statement that names `site.module`.
+ */
+function reportedRanges(root, site) {
+    const line = site.line;
+    const range = [{ row: line - 1, column: 0 }, { row: line, column: 0 }];
+    const rows = node => [node.startPosition.row + 1, node.endPosition.row + 1];
+    const spans = node => node.startPosition.row + 1 <= line && node.endPosition.row + 1 >= line;
+    if (site.kind === 'arity') {
+        const nameOf = call => {
+            const callee = call.childForFieldName('function');
+            return callee ? (callee.childForFieldName('attribute') || callee) : null;
+        };
+        const call = site.span ? callAtSpan(root, site.span)
+            : root.descendantsOfType('call', ...range).filter(candidate => {
+                const named = nameOf(candidate);
+                return !!named && named.startPosition.row + 1 === line;
+            }).find((candidate, at, all) => !site.name || nameOf(candidate).text === site.name ||
+                !all.some(other => nameOf(other).text === site.name));
+        if (!call) return [[line, line]];
+        const given = (call.childForFieldName('arguments')?.namedChildren || [])
+            .filter(argument => argument.type !== 'comment');
+        const keyword = name => given.find(argument => argument.type === 'keyword_argument' &&
+            argument.childForFieldName('name')?.text === name);
+        const reports = [];
+        // What the call was measured against, problem by problem.
+        for (const problem of String(site.problem || '').split('; ').filter(Boolean)) {
+            const named = /'([^']+)'/.exec(problem);
+            if (/^takes \d+ positional/.test(problem)) {
+                const positional = given.filter(argument => argument.type !== 'keyword_argument');
+                const count = Number(/^takes (\d+)/.exec(problem)[1]);
+                reports.push(rows(positional[count] || call));
+            } else if (named && !/^missing/.test(problem) && keyword(named[1])) {
+                reports.push(rows(keyword(named[1])));
+            } else {
+                reports.push(rows(call));
+            }
+        }
+        if (reports.length > 0) return reports;
+        if (Number.isInteger(site.most) && given.length > site.most) return [rows(given[site.most])];
+        return [rows(call)];
+    }
+    if (site.kind === 'import-name' || site.kind === 'import-module') {
+        const statements = root.descendantsOfType(['import_from_statement', 'import_statement'], ...range).filter(spans);
+        const moduleOf = statement => statement.childForFieldName('module_name') ||
+            statement.namedChildren.find(child => child.type === 'dotted_name' || child.type === 'aliased_import');
+        const naming = site.module === undefined ? statements
+            : statements.filter(statement => statement.descendantsOfType(['dotted_name', 'relative_import'])
+                .some(node => node.text === site.module));
+        for (const statement of naming.length > 0 ? naming : statements) {
+            if (site.kind === 'import-name') {
+                const named = statement.descendantsOfType(['dotted_name', 'identifier'])
+                    .find(node => node.text === site.name);
+                if (named) return [rows(named)];
+            }
+            const module = moduleOf(statement);
+            if (module) return [rows(module)];
+        }
+    }
+    return [[line, line]];
+}
+
+/**
+ * Has the type checker been told not to report this break? As pyright
+ * reads its comments: a `type: ignore` before any code, the break's rule
+ * set to anything but an error by a `# pyright:` comment, or a
+ * `type: ignore` / `pyright: ignore` comment (naming the rule, when it
+ * names any) on a line of every range it is reported over.
+ *
+ * @param {object} site - { lines, root, line, kind, name, most, span,
+ *   problem, module, memo }
+ */
+function checkSuppressedAt(site) {
+    const { 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.all) return true;
+    const rule = RULE_OF[site.kind] || null;
+    const level = rule ? directives.levels.get(rule) : undefined;
+    if (level !== undefined && level !== 'true' && level !== 'error') return true;
+    const silenced = ([first, last]) => {
+        for (let at = first; at <= last; at++) {
+            if (!directives.ignored.has(at)) continue;
+            const rules = directives.ignored.get(at);
+            if (rules === null || (rule !== null && rules.includes(rule))) return true;
+        }
+        return false;
+    };
+    return reportedRanges(root, site).every(silenced);
+}
+
+/**
+ * Is the import written on `line` a statement the type checker resolves?
+ * `importlib.import_module(..)` and `__import__(..)` are calls to it.
+ * Several imports can share a line: the one asked about is the one that
+ * names `module`, as it is written.
+ */
+function checkedImportAt(root, line, module) {
+    const range = [{ row: line - 1, column: 0 }, { row: line, column: 0 }];
+    return root.descendantsOfType(['import_statement', 'import_from_statement', 'future_import_statement'], ...range)
+        .some(node => node.startPosition.row + 1 <= line && node.endPosition.row + 1 >= line &&
+            (module === undefined || node.descendantsOfType(['dotted_name', 'relative_import'])
+                .some(named => named.text === module)));
+}
+
 module.exports = {
+    checkDirectiveComment,
+    checkFileDirectiveComment,
+    checkSuppressedAt,
+    checkedImportAt,
     annotatedReceiverType,
     findScopeAlternativeBindings,
     findPythonModuleEvidence,
@@ -5865,5 +7569,6 @@ module.exports = {
     findPytestFunctions,
     isEntryPoint,
     getEntryPointKind,
+    testUnits,
     parse
 };