@descryy/runtime-test-runner 0.4.12 → 0.4.14

package/dist/quality/python-family.js

@@ -0,0 +1,786 @@
+import { argsOf, parseChain } from "./chains.js";
+import { allChains, chainsInRange, spanSetOf } from "./common.js";
+import { durationMs } from "./durations.js";
+import { isNullLiteralRange } from "./expressions.js";
+import { EXISTENCE, negate, SNAPSHOT, STRONG, STRONG_THROWS, STRONG_URL, STRONG_VALUE, strongerOf, strongStatus, WEAK, weakerOf } from "./assertion-kinds.js";
+import { selectorFromBy, selectorFromCall } from "./selectors.js";
+import { isStatusSubject, isUrlSubject, statusFromTokens } from "./statuses.js";
+import { endLineOf, isIdent, isPunct, lineOf, splitTopLevel, stringValue, textAt, textOf } from "./stream.js";
+const CHAIN_OPTIONS = { generics: false, sameLine: true };
+function buildLayout(stream) {
+    const toks = stream.toks;
+    const stmtStart = new Int32Array(toks.length).fill(0);
+    const stmtId = new Int32Array(toks.length).fill(0);
+    const starts = [];
+    let depth = 0;
+    let current = 0;
+    for (let index = 0; index < toks.length; index += 1) {
+        const token = toks[index];
+        const previous = toks[index - 1];
+        let begins = index === 0;
+        if (!begins && depth === 0) {
+            const continued = previous.kind === "punctuator" && previous.text === "\\";
+            if (!continued && endLineOf(previous) < token.line)
+                begins = true;
+            else if (previous.kind === "punctuator" && previous.text === ";")
+                begins = true;
+        }
+        if (begins) {
+            current = index;
+            starts.push(index);
+        }
+        stmtStart[index] = current;
+        stmtId[index] = starts.length - 1;
+        if (token.kind === "punctuator") {
+            if (token.text === "(" || token.text === "[" || token.text === "{")
+                depth += 1;
+            else if (token.text === ")" || token.text === "]" || token.text === "}")
+                depth = Math.max(0, depth - 1);
+        }
+    }
+    return { stmtStart, starts, stmtId };
+}
+function statementEnd(stream, layout, start) {
+    const id = layout.stmtId[start];
+    const next = layout.starts[id + 1];
+    return next === undefined ? stream.toks.length - 1 : next - 1;
+}
+function blockEnd(stream, layout, start) {
+    const headerEnd = statementEnd(stream, layout, start);
+    if (textAt(stream, headerEnd) !== ":")
+        return headerEnd;
+    const indent = stream.toks[layout.stmtStart[start]].column;
+    let index = headerEnd + 1;
+    while (index < stream.toks.length) {
+        if (layout.stmtStart[index] === index && stream.toks[index].column <= indent)
+            break;
+        index += 1;
+    }
+    return index - 1;
+}
+function bodyIndent(stream, layout, start) {
+    const headerEnd = statementEnd(stream, layout, start);
+    if (textAt(stream, headerEnd) !== ":")
+        return null;
+    const first = stream.toks[headerEnd + 1];
+    return first === undefined ? null : first.column;
+}
+function decoratorsBefore(stream, layout, declarationStart) {
+    const found = [];
+    let cursor = declarationStart;
+    while (cursor > 0) {
+        const previous = cursor - 1;
+        const start = layout.stmtStart[previous];
+        if (!isPunct(stream, start, "@"))
+            break;
+        found.push({ start, end: statementEnd(stream, layout, start) });
+        cursor = start;
+    }
+    return found;
+}
+function chainOfDecorator(stream, decorator) {
+    if (stream.toks[decorator.start + 1]?.kind !== "identifier")
+        return null;
+    return parseChain(stream, decorator.start + 1, CHAIN_OPTIONS);
+}
+const SKIP_NAMES = new Set(["skip", "skipif", "skipIf", "skipUnless", "skip_if", "skip_unless", "skip_on", "skipTest"]);
+function decoratorSkips(stream, decorators) {
+    for (const decorator of decorators) {
+        const chain = chainOfDecorator(stream, decorator);
+        if (chain === null)
+            continue;
+        if (chain.segments.some((segment) => SKIP_NAMES.has(segment.name)))
+            return true;
+    }
+    return false;
+}
+const WEAK_CALLS = new Set(["len", "bool"]);
+const EXISTENCE_CALLS = new Set(["hasattr", "exists", "isfile", "isdir", "is_file", "is_dir", "isexists", "path_exists"]);
+function snapshotReference(stream, from, last) {
+    for (let index = from; index <= last; index += 1) {
+        const token = stream.toks[index];
+        if (token.kind === "identifier" && (token.text === "snapshot" || token.text === "match_snapshot" || token.text === "matches_snapshot"))
+            return true;
+    }
+    return false;
+}
+function stripParentheses(stream, from, last) {
+    let start = from;
+    let end = last;
+    while (end > start && isPunct(stream, start, "(") && stream.match[start] === end) {
+        start += 1;
+        end -= 1;
+    }
+    return [start, end];
+}
+function splitOnKeyword(stream, from, last, keyword) {
+    const parts = [];
+    let start = from;
+    let index = from;
+    while (index <= last) {
+        const token = stream.toks[index];
+        if (token.kind === "punctuator" && (token.text === "(" || token.text === "[" || token.text === "{") && stream.match[index] > index) {
+            index = stream.match[index] + 1;
+            continue;
+        }
+        if (token.kind === "identifier" && token.text === keyword && index > start) {
+            parts.push([start, index - 1]);
+            start = index + 1;
+        }
+        index += 1;
+    }
+    if (start <= last)
+        parts.push([start, last]);
+    return parts;
+}
+const COMPARISON_PUNCTUATION = new Set(["==", "!=", "<", ">", "<=", ">="]);
+function findComparison(stream, from, last) {
+    let index = from;
+    while (index <= last) {
+        const token = stream.toks[index];
+        if (token.kind === "punctuator") {
+            if ((token.text === "(" || token.text === "[" || token.text === "{") && stream.match[index] > index) {
+                index = stream.match[index] + 1;
+                continue;
+            }
+            if (COMPARISON_PUNCTUATION.has(token.text) && index > from && index < last)
+                return { operator: token.text, left: [from, index - 1], right: [index + 1, last] };
+        }
+        else if (token.kind === "identifier" && index > from) {
+            if (token.text === "in" && index < last)
+                return { operator: "in", left: [from, index - 1], right: [index + 1, last] };
+            if (token.text === "not" && isIdent(stream, index + 1, "in") && index + 1 < last)
+                return { operator: "not in", left: [from, index - 1], right: [index + 2, last] };
+            if (token.text === "is" && index < last) {
+                if (isIdent(stream, index + 1, "not") && index + 1 < last)
+                    return { operator: "is not", left: [from, index - 1], right: [index + 2, last] };
+                return { operator: "is", left: [from, index - 1], right: [index + 1, last] };
+            }
+        }
+        index += 1;
+    }
+    return null;
+}
+function comparesWithNone(stream, from, last) {
+    const [start, end] = stripParentheses(stream, from, last);
+    const comparison = findComparison(stream, start, end);
+    if (comparison === null || (comparison.operator !== "is" && comparison.operator !== "==" && comparison.operator !== "is not" && comparison.operator !== "!="))
+        return false;
+    return isNullLiteralRange(stream, comparison.left[0], comparison.left[1]) || isNullLiteralRange(stream, comparison.right[0], comparison.right[1]);
+}
+function bareCallName(stream, from, last) {
+    if (stream.toks[from]?.kind !== "identifier")
+        return null;
+    const chain = parseChain(stream, from, CHAIN_OPTIONS);
+    if (chain.end !== last)
+        return null;
+    const finalSegment = chain.segments[chain.segments.length - 1];
+    return { name: finalSegment.name, wholeCall: finalSegment.open >= 0 };
+}
+const DEPTH_LIMIT = 48;
+export function classifyPythonExpression(stream, fromIndex, lastIndex, depth = 0) {
+    if (depth > DEPTH_LIMIT)
+        return STRONG;
+    const [from, last] = stripParentheses(stream, fromIndex, lastIndex);
+    if (last < from)
+        return WEAK;
+    const disjuncts = splitOnKeyword(stream, from, last, "or");
+    if (disjuncts.length > 1)
+        return disjuncts.map((part) => classifyPythonExpression(stream, part[0], part[1], depth + 1)).reduce(weakerOf);
+    const conjuncts = splitOnKeyword(stream, from, last, "and");
+    if (conjuncts.length > 1)
+        return conjuncts.map((part) => classifyPythonExpression(stream, part[0], part[1], depth + 1)).reduce(strongerOf);
+    if (isIdent(stream, from, "not") && !isIdent(stream, from + 1, "in") && from < last) {
+        if (comparesWithNone(stream, from + 1, last))
+            return WEAK;
+        return negate(classifyPythonExpression(stream, from + 1, last, depth + 1));
+    }
+    const comparison = findComparison(stream, from, last);
+    if (comparison !== null) {
+        const { operator, left, right } = comparison;
+        if (operator === "==") {
+            if (snapshotReference(stream, left[0], left[1]) || snapshotReference(stream, right[0], right[1]))
+                return SNAPSHOT;
+            if (isStatusSubject(stream, left[0], left[1])) {
+                const value = statusFromTokens(stream, right[0], right[1]);
+                if (value !== null)
+                    return strongStatus(value);
+            }
+            if (isStatusSubject(stream, right[0], right[1])) {
+                const value = statusFromTokens(stream, left[0], left[1]);
+                if (value !== null)
+                    return strongStatus(value);
+            }
+            if (isUrlSubject(stream, left[0], left[1]) || isUrlSubject(stream, right[0], right[1]))
+                return STRONG_URL;
+            return STRONG_VALUE;
+        }
+        if (operator === "!=" || operator === "is not")
+            return isNullLiteralRange(stream, left[0], left[1]) || isNullLiteralRange(stream, right[0], right[1]) ? WEAK : STRONG;
+        if (operator === "not in")
+            return STRONG;
+        return STRONG_VALUE;
+    }
+    const call = bareCallName(stream, from, last);
+    if (call !== null) {
+        if (!call.wholeCall)
+            return WEAK;
+        if (WEAK_CALLS.has(call.name))
+            return WEAK;
+        if (EXISTENCE_CALLS.has(call.name))
+            return EXISTENCE;
+        if (call.name === "snapshot" || call.name === "match_snapshot")
+            return SNAPSHOT;
+        return STRONG;
+    }
+    if (from === last && stream.toks[from].kind === "identifier")
+        return WEAK;
+    return STRONG;
+}
+const UNITTEST_THROWS = /^assert(Raises|RaisesRegex|Raises_regex|Throws)$/;
+const UNITTEST_NEGATED = /^assert(Not|IsNot)/;
+function classifyUnittest(stream, segment) {
+    const name = segment.name;
+    const args = argsOf(stream, segment);
+    if (UNITTEST_THROWS.test(name))
+        return STRONG_THROWS;
+    if (/^assertMatch.*Snapshot$/.test(name) || name === "assertSnapshot")
+        return SNAPSHOT;
+    if (name === "assertTrue" || name === "assertFalse") {
+        if (args[0] === undefined)
+            return null;
+        if (name === "assertFalse" && comparesWithNone(stream, args[0][0], args[0][1]))
+            return WEAK;
+        const inner = classifyPythonExpression(stream, args[0][0], args[0][1]);
+        return name === "assertFalse" ? negate(inner) : inner;
+    }
+    if (name === "assertIsNotNone")
+        return WEAK;
+    if (UNITTEST_NEGATED.test(name)) {
+        const operands = args.slice(0, 2);
+        if (operands.length < 2)
+            return WEAK;
+        return operands.some((operand) => isNullLiteralRange(stream, operand[0], operand[1])) ? WEAK : STRONG;
+    }
+    if (name === "assertEqual" || name === "assertEquals" || name === "assertDictEqual" || name === "assertListEqual") {
+        if (args.length >= 2) {
+            for (const [subject, other] of [[args[0], args[1]], [args[1], args[0]]]) {
+                if (isStatusSubject(stream, subject[0], subject[1])) {
+                    const value = statusFromTokens(stream, other[0], other[1]);
+                    if (value !== null)
+                        return strongStatus(value);
+                }
+            }
+            if (isUrlSubject(stream, args[0][0], args[0][1]) || isUrlSubject(stream, args[1][0], args[1][1]))
+                return STRONG_URL;
+        }
+        return STRONG_VALUE;
+    }
+    if (name === "assertContains" || name === "assertRedirects") {
+        for (let index = segment.open + 1; index < segment.close; index += 1) {
+            if (isIdent(stream, index, "status_code") && isPunct(stream, index + 1, "=")) {
+                const value = statusFromTokens(stream, index + 2, index + 2);
+                if (value !== null)
+                    return strongStatus(value);
+            }
+        }
+        return STRONG_VALUE;
+    }
+    return STRONG_VALUE;
+}
+const MOCK_STRONG = new Set(["assert_called_with", "assert_called_once_with", "assert_any_call", "assert_has_calls", "assert_awaited_with", "assert_awaited_once_with", "assert_not_called", "assert_called_once", "assert_awaited_once", "assert_not_awaited", "assert_has_awaits", "assert_any_await"]);
+const MOCK_WEAK = new Set(["assert_called", "assert_awaited"]);
+function pythonCallAssertion(stream, chain) {
+    const segments = chain.segments;
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (segment.open < 0)
+            continue;
+        if (segment.name === "raises" && index >= 1 && segments[index - 1].name === "pytest")
+            return { nameIndex: segment.nameIndex, classified: STRONG_THROWS };
+        if ((segment.name === "warns" || segment.name === "deprecated_call") && index >= 1 && segments[index - 1].name === "pytest")
+            return { nameIndex: segment.nameIndex, classified: STRONG };
+        if (/^assert[A-Z]/.test(segment.name) && index >= 1) {
+            const classified = classifyUnittest(stream, segment);
+            if (classified !== null)
+                return { nameIndex: segment.nameIndex, classified };
+        }
+        if (segment.name.startsWith("assert_") && index >= 1) {
+            if (segment.name === "assert_match" && /snapshot/i.test(segments[index - 1].name))
+                return { nameIndex: segment.nameIndex, classified: SNAPSHOT };
+            if (MOCK_STRONG.has(segment.name))
+                return { nameIndex: segment.nameIndex, classified: STRONG };
+            if (MOCK_WEAK.has(segment.name))
+                return { nameIndex: segment.nameIndex, classified: WEAK };
+            return { nameIndex: segment.nameIndex, classified: STRONG_VALUE };
+        }
+        if ((segment.name === "assert_match_snapshot" || segment.name === "match_snapshot") && index === 0)
+            return { nameIndex: segment.nameIndex, classified: SNAPSHOT };
+    }
+    return null;
+}
+function stringArg(stream, segment, position) {
+    const range = argsOf(stream, segment)[position];
+    if (range === undefined || range[0] !== range[1])
+        return null;
+    return stringValue(stream.toks[range[0]]);
+}
+function dotted(target) {
+    const cut = target.lastIndexOf(".");
+    if (cut <= 0 || cut === target.length - 1)
+        return null;
+    return { module: target.slice(0, cut), symbol: target.slice(cut + 1) };
+}
+const MOCK_FACTORIES = new Set(["MagicMock", "Mock", "AsyncMock", "PropertyMock", "NonCallableMock", "NonCallableMagicMock", "create_autospec"]);
+const NETWORK_HEADS = new Set(["responses", "requests_mock", "httpretty", "respx", "aioresponses", "vcr", "HTTPretty", "httpx_mock", "pook"]);
+function pythonMocksOf(stream, chain) {
+    const segments = chain.segments;
+    const found = [];
+    const first = segments[0];
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (index === 0 && NETWORK_HEADS.has(segment.name) && segments.length >= 2 && segments[1].name !== "") {
+            found.push({ nameIndex: segments[1].nameIndex, kind: "network", module: null, symbol: null });
+            continue;
+        }
+        if (segment.open < 0 && segment.name !== "patch")
+            continue;
+        if (segment.name === "patch") {
+            const member = segments[index + 1];
+            if (member !== undefined && (member.name === "dict" || member.name === "stopall" || member.name === "stop"))
+                continue;
+            if (member !== undefined && member.name === "object" && member.open >= 0) {
+                found.push({ nameIndex: member.nameIndex, kind: "function", module: null, symbol: stringArg(stream, member, 1) });
+                continue;
+            }
+            if (member !== undefined && member.name === "multiple" && member.open >= 0) {
+                found.push({ nameIndex: member.nameIndex, kind: "function", module: null, symbol: null });
+                continue;
+            }
+            if (segment.open >= 0) {
+                const target = stringArg(stream, segment, 0);
+                const split = target === null ? null : dotted(target);
+                if (split !== null)
+                    found.push({ nameIndex: segment.nameIndex, kind: "function", module: split.module, symbol: split.symbol });
+                else
+                    found.push({ nameIndex: segment.nameIndex, kind: target === null ? "function" : "module", module: target, symbol: null });
+            }
+            continue;
+        }
+        if (segment.name === "setattr" && index >= 1 && /monkeypatch|^mp$/i.test(segments[index - 1].name)) {
+            const target = stringArg(stream, segment, 0);
+            const split = target === null ? null : dotted(target);
+            if (split !== null)
+                found.push({ nameIndex: segment.nameIndex, kind: "function", module: split.module, symbol: split.symbol });
+            else
+                found.push({ nameIndex: segment.nameIndex, kind: "function", module: null, symbol: stringArg(stream, segment, 1) });
+            continue;
+        }
+        if ((segment.name === "spy" || segment.name === "stub") && index >= 1 && segments[index - 1].name === "mocker") {
+            found.push({ nameIndex: segment.nameIndex, kind: "function", module: null, symbol: segment.name === "spy" ? stringArg(stream, segment, 1) : null });
+            continue;
+        }
+        if (MOCK_FACTORIES.has(segment.name) && segment.open >= 0) {
+            found.push({ nameIndex: segment.nameIndex, kind: "function", module: null, symbol: null });
+            continue;
+        }
+        if (segment.name === "freeze_time" && segment.open >= 0) {
+            found.push({ nameIndex: segment.nameIndex, kind: "timer", module: null, symbol: null });
+            continue;
+        }
+        if (segment.name === "travel" && index >= 1 && segments[index - 1].name === "time_machine" && segment.open >= 0) {
+            found.push({ nameIndex: segment.nameIndex, kind: "timer", module: null, symbol: null });
+            continue;
+        }
+        if (segment.name === "use_cassette" && segment.open >= 0)
+            found.push({ nameIndex: segment.nameIndex, kind: "network", module: null, symbol: null });
+        if (segment.name === "aioresponses" && segment.open >= 0 && index === 0)
+            found.push({ nameIndex: segment.nameIndex, kind: "network", module: null, symbol: null });
+    }
+    if (first.name === "freezegun" && segments[1]?.name === "freeze_time" && found.length === 0)
+        found.push({ nameIndex: segments[1].nameIndex, kind: "timer", module: null, symbol: null });
+    return found;
+}
+const SLEEP_RECEIVERS = new Set(["time", "asyncio", "trio", "anyio", "gevent", "eventlet"]);
+function pythonSleepOf(stream, chain) {
+    const segments = chain.segments;
+    const last = segments[segments.length - 1];
+    if (last.name !== "sleep" || last.open < 0)
+        return null;
+    if (segments.length > 1 && !SLEEP_RECEIVERS.has(segments[segments.length - 2].name))
+        return null;
+    const range = argsOf(stream, last)[0];
+    return { nameIndex: last.nameIndex, ms: range === undefined ? null : durationMs(stream, range[0], range[1], 1000) };
+}
+function pythonSelectors(stream, chain) {
+    const found = [];
+    const segments = chain.segments;
+    const head = segments[0].name;
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (segment.open < 0 || segment.name === "")
+            continue;
+        const args = argsOf(stream, segment);
+        const normalised = segment.name.toLowerCase().replace(/_/g, "");
+        if ((normalised === "findelement" || normalised === "findelements") && args.length >= 2) {
+            const locator = args[0];
+            const value = args[1];
+            const byName = locator[1] - locator[0] === 2 && isIdent(stream, locator[0], "By") && isPunct(stream, locator[0] + 1, ".") ? textAt(stream, locator[1]) : null;
+            const text = value[0] === value[1] ? stringValue(stream.toks[value[0]]) : null;
+            if (byName !== null && text !== null) {
+                const candidate = selectorFromBy(byName, text);
+                if (candidate !== null)
+                    found.push({ nameIndex: segment.nameIndex, text: candidate.text, stability: candidate.stability });
+            }
+            continue;
+        }
+        const first = args[0];
+        const text = first !== undefined && first[0] === first[1] ? stringValue(stream.toks[first[0]]) : null;
+        if (text === null)
+            continue;
+        const candidate = selectorFromCall(segment.name, index > 0 ? segments[index - 1].name : null, text, { head, allowFind: false });
+        if (candidate !== null)
+            found.push({ nameIndex: segment.nameIndex, text: candidate.text, stability: candidate.stability });
+    }
+    return found;
+}
+const HELPER_EXCLUDED = new Set([
+    "print", "len", "range", "str", "int", "float", "bool", "list", "dict", "set", "tuple", "frozenset", "sorted", "reversed", "enumerate", "zip", "map", "filter", "min", "max", "sum", "any", "all", "abs", "round", "isinstance", "issubclass", "hasattr", "getattr", "setattr", "delattr", "type", "repr", "open", "iter", "next", "id", "hash", "format", "bytes", "bytearray", "callable", "vars", "dir", "super", "object", "input", "eval", "exec", "compile", "divmod", "pow", "chr", "ord", "hex", "oct", "bin", "slice", "memoryview", "property", "staticmethod", "classmethod", "globals", "locals", "ascii", "complex", "if", "while", "for", "return", "assert", "lambda", "yield", "await", "not", "and", "or", "in", "is", "with", "print_",
+    "patch", "MagicMock", "Mock", "AsyncMock", "call", "mock_open", "sentinel", "PropertyMock", "create_autospec", "freeze_time", "sleep", "skip", "fixture", "param", "raises", "approx", "fail", "parametrize", "mark", "snapshot", "responses", "aioresponses",
+]);
+function pythonHelperOf(stream, chain) {
+    const segments = chain.segments;
+    if (segments.length !== 1)
+        return null;
+    const only = segments[0];
+    if (only.open < 0 || HELPER_EXCLUDED.has(only.name))
+        return null;
+    if (/^[A-Z]/.test(only.name) || /(Error|Exception|Warning)$/.test(only.name))
+        return null;
+    const previous = stream.toks[chain.head - 1];
+    if (previous !== undefined && previous.kind === "identifier" && (previous.text === "def" || previous.text === "class" || previous.text === "import" || previous.text === "from" || previous.text === "as"))
+        return null;
+    return only.name;
+}
+function collectDefinitions(stream, layout) {
+    const definitions = [];
+    for (const start of layout.starts) {
+        let index = start;
+        if (isIdent(stream, index, "async") && isIdent(stream, index + 1, "def"))
+            index += 1;
+        const token = stream.toks[index];
+        if (token === undefined || token.kind !== "identifier" || (token.text !== "def" && token.text !== "class"))
+            continue;
+        const name = stream.toks[index + 1];
+        if (name === undefined || name.kind !== "identifier")
+            continue;
+        definitions.push({ start, defIndex: index, nameIndex: index + 1, name: name.text, kind: token.text });
+    }
+    return definitions;
+}
+const HOOK_FUNCTIONS = {
+    setUp: { kind: "setup", scope: "each" },
+    asyncSetUp: { kind: "setup", scope: "each" },
+    tearDown: { kind: "teardown", scope: "each" },
+    asyncTearDown: { kind: "teardown", scope: "each" },
+    setup_method: { kind: "setup", scope: "each" },
+    teardown_method: { kind: "teardown", scope: "each" },
+    setup_function: { kind: "setup", scope: "each" },
+    teardown_function: { kind: "teardown", scope: "each" },
+    setUpClass: { kind: "setup", scope: "all" },
+    tearDownClass: { kind: "teardown", scope: "all" },
+    setUpModule: { kind: "setup", scope: "all" },
+    tearDownModule: { kind: "teardown", scope: "all" },
+    setup_class: { kind: "setup", scope: "all" },
+    teardown_class: { kind: "teardown", scope: "all" },
+    setup_module: { kind: "setup", scope: "all" },
+    teardown_module: { kind: "teardown", scope: "all" },
+};
+const ASSIGNMENT_TOKENS = new Set(["=", "+=", "-=", "*=", "/=", "//=", "%=", "**=", "@=", "&=", "|=", "^=", ">>=", "<<=", ":="]);
+const MUTATORS = new Set(["append", "extend", "update", "add", "remove", "pop", "clear", "insert", "setdefault", "discard", "popitem", "sort", "reverse", "put", "put_nowait"]);
+function fixtureInfo(stream, decorators) {
+    for (const decorator of decorators) {
+        const chain = chainOfDecorator(stream, decorator);
+        if (chain === null)
+            continue;
+        const fixture = chain.segments.find((segment) => segment.name === "fixture");
+        if (fixture === undefined)
+            continue;
+        let autouse = false;
+        let scope = "each";
+        if (fixture.open >= 0) {
+            for (let index = fixture.open + 1; index < fixture.close; index += 1) {
+                if (isIdent(stream, index, "autouse") && isPunct(stream, index + 1, "=") && isIdent(stream, index + 2, "True"))
+                    autouse = true;
+                if (isIdent(stream, index, "scope") && isPunct(stream, index + 1, "=")) {
+                    const value = stringValue(stream.toks[index + 2]);
+                    if (value !== null && value !== "function")
+                        scope = "all";
+                }
+            }
+        }
+        return { autouse, scope };
+    }
+    return null;
+}
+function containsYield(stream, from, to) {
+    for (let index = from; index <= to; index += 1)
+        if (isIdent(stream, index, "yield"))
+            return true;
+    return false;
+}
+function nestedFunctionSpans(stream, layout, definitions, first, last) {
+    const spans = [];
+    const enclosingEnds = [];
+    for (const candidate of definitions) {
+        if (candidate.kind !== "def" || candidate.defIndex < first || candidate.defIndex > last)
+            continue;
+        while (enclosingEnds.length > 0 && enclosingEnds[enclosingEnds.length - 1] < candidate.start)
+            enclosingEnds.pop();
+        const end = blockEnd(stream, layout, candidate.start);
+        if (enclosingEnds.length > 0)
+            spans.push([candidate.defIndex, end]);
+        enclosingEnds.push(end);
+    }
+    return spanSetOf(spans);
+}
+export function extractPython(scope) {
+    const { stream, first, last, out } = scope;
+    const layout = buildLayout(stream);
+    const definitions = collectDefinitions(stream, layout);
+    const chains = allChains(stream, CHAIN_OPTIONS);
+    const rangeChains = chainsInRange(chains, first, last);
+    let nestedFunctions = null;
+    for (let index = first; index <= last; index += 1) {
+        const token = stream.toks[index];
+        if (token.kind !== "identifier" || token.text !== "assert")
+            continue;
+        const previous = stream.toks[index - 1];
+        const startsStatement = layout.stmtStart[index] === index || (previous !== undefined && previous.kind === "punctuator" && previous.text === ":");
+        if (!startsStatement)
+            continue;
+        const end = statementEnd(stream, layout, layout.stmtStart[index]);
+        if (end <= index)
+            continue;
+        const parts = splitTopLevel(stream, index + 1, end);
+        const expression = parts[0];
+        if (expression === undefined)
+            continue;
+        const classified = classifyPythonExpression(stream, expression[0], expression[1]);
+        out.assertions.push({ line: token.line, strength: classified.strength, expects: classified.expects, text: textOf(stream, index, end) });
+    }
+    for (const chain of rangeChains) {
+        const assertion = pythonCallAssertion(stream, chain);
+        if (assertion !== null)
+            out.assertions.push({ line: lineOf(stream, assertion.nameIndex), strength: assertion.classified.strength, expects: assertion.classified.expects, text: textOf(stream, chain.head, chain.end) });
+        for (const mock of pythonMocksOf(stream, chain))
+            out.mocks.push({ line: lineOf(stream, mock.nameIndex), module: mock.module, symbol: mock.symbol, kind: mock.kind });
+        const sleep = pythonSleepOf(stream, chain);
+        if (sleep !== null) {
+            nestedFunctions ??= nestedFunctionSpans(stream, layout, definitions, first, last);
+            if (!nestedFunctions.contains(chain.head))
+                out.sleeps.push({ line: lineOf(stream, sleep.nameIndex), ms: sleep.ms });
+        }
+        for (const selector of pythonSelectors(stream, chain))
+            out.selectors.push({ line: lineOf(stream, selector.nameIndex), text: selector.text, stability: selector.stability });
+        const helper = pythonHelperOf(stream, chain);
+        if (helper !== null)
+            out.helperCalls.push({ line: lineOf(stream, chain.head), name: helper });
+    }
+    const subject = definitions.find((definition) => definition.kind === "def" && definition.start >= first && definition.start <= last);
+    const enclosingClasses = (subject === undefined ? definitions.filter((d) => d.kind === "class" && d.start >= first && d.start <= last).slice(0, 1) : definitions.filter((d) => d.kind === "class" && d.start < subject.start && blockEnd(stream, layout, d.start) >= subject.start));
+    const decorated = [];
+    if (subject !== undefined)
+        decorated.push(decoratorsBefore(stream, layout, subject.start));
+    for (const owner of enclosingClasses)
+        decorated.push(decoratorsBefore(stream, layout, owner.start));
+    for (const decorators of decorated) {
+        if (decoratorSkips(stream, decorators))
+            out.skipped = true;
+        for (const decorator of decorators) {
+            const chain = chainOfDecorator(stream, decorator);
+            if (chain === null)
+                continue;
+            for (const mock of pythonMocksOf(stream, chain))
+                out.mocks.push({ line: lineOf(stream, mock.nameIndex), module: mock.module, symbol: mock.symbol, kind: mock.kind });
+        }
+    }
+    if (subject !== undefined) {
+        const indent = bodyIndent(stream, layout, subject.start);
+        const end = blockEnd(stream, layout, subject.start);
+        for (const chain of chains) {
+            if (chain.head <= subject.defIndex || chain.head > end)
+                continue;
+            if (layout.stmtStart[chain.head] !== chain.head || stream.toks[chain.head].column !== indent)
+                continue;
+            const names = chain.segments.map((segment) => segment.name);
+            const unconditional = (names[0] === "pytest" && names[1] === "skip") || (names[0] === "self" && names[1] === "skipTest") || (names[0] === "unittest" && names[1] === "skip");
+            if (unconditional)
+                out.skipped = true;
+        }
+    }
+    for (const start of layout.starts) {
+        if (stream.toks[start].column !== 1)
+            continue;
+        if (!isIdent(stream, start, "pytestmark"))
+            continue;
+        const end = statementEnd(stream, layout, start);
+        for (let index = start; index <= end; index += 1)
+            if (SKIP_NAMES.has(textAt(stream, index)))
+                out.skipped = true;
+    }
+    for (const definition of definitions) {
+        if (definition.kind !== "def")
+            continue;
+        const hook = HOOK_FUNCTIONS[definition.name];
+        if (hook !== undefined) {
+            out.hooks.push({ line: lineOf(stream, definition.defIndex), kind: hook.kind, scope: hook.scope });
+            continue;
+        }
+        const decorators = decoratorsBefore(stream, layout, definition.start);
+        const fixture = fixtureInfo(stream, decorators);
+        if (fixture === null)
+            continue;
+        const end = blockEnd(stream, layout, definition.start);
+        const line = lineOf(stream, definition.defIndex);
+        if (containsYield(stream, definition.defIndex, end)) {
+            out.hooks.push({ line, kind: "setup", scope: fixture.scope });
+            out.hooks.push({ line, kind: "teardown", scope: fixture.scope });
+        }
+        else if (fixture.autouse)
+            out.hooks.push({ line, kind: "setup", scope: fixture.scope });
+    }
+    for (const chain of chains) {
+        const lastSegment = chain.segments[chain.segments.length - 1];
+        if (lastSegment.open < 0)
+            continue;
+        if (lastSegment.name === "addCleanup" || lastSegment.name === "addfinalizer" || lastSegment.name === "addAsyncCleanup")
+            out.hooks.push({ line: lineOf(stream, chain.head), kind: "teardown", scope: "each" });
+        if (lastSegment.name === "addClassCleanup")
+            out.hooks.push({ line: lineOf(stream, chain.head), kind: "teardown", scope: "all" });
+    }
+    collectPythonSharedState(scope, layout, definitions);
+}
+function collectPythonSharedState(scope, layout, definitions) {
+    const { stream, first, last, out } = scope;
+    if (first > last)
+        return;
+    const moduleNames = new Set();
+    const classNames = new Set();
+    const classAttributes = new Set();
+    const assignmentTarget = (start) => {
+        const token = stream.toks[start];
+        if (token === undefined || token.kind !== "identifier")
+            return null;
+        const next = stream.toks[start + 1];
+        if (next === undefined || next.kind !== "punctuator")
+            return null;
+        if (next.text === "=" || (next.text === ":" && isPunct(stream, start + 3, "=")) || (next.text === ":" && stream.toks[start + 2]?.kind === "identifier" && isPunct(stream, start + 3, "=")))
+            return token.text;
+        return null;
+    };
+    for (const start of layout.starts) {
+        if (stream.toks[start].column !== 1)
+            continue;
+        const name = assignmentTarget(start);
+        if (name !== null)
+            moduleNames.add(name);
+    }
+    for (const definition of definitions) {
+        if (definition.kind !== "class")
+            continue;
+        classNames.add(definition.name);
+        const indent = bodyIndent(stream, layout, definition.start);
+        const end = blockEnd(stream, layout, definition.start);
+        if (indent === null)
+            continue;
+        for (const start of layout.starts) {
+            if (start <= definition.defIndex || start > end || stream.toks[start].column !== indent)
+                continue;
+            const name = assignmentTarget(start);
+            if (name !== null)
+                classAttributes.add(name);
+        }
+    }
+    if (moduleNames.size === 0 && classAttributes.size === 0)
+        return;
+    const globals = new Set();
+    const parameters = new Set();
+    const locals = new Set();
+    for (let index = first; index <= last; index += 1) {
+        const token = stream.toks[index];
+        if (token.kind === "identifier" && token.text === "global" && layout.stmtStart[index] === index) {
+            const end = statementEnd(stream, layout, index);
+            for (let cursor = index + 1; cursor <= end; cursor += 1)
+                if (stream.toks[cursor].kind === "identifier")
+                    globals.add(stream.toks[cursor].text);
+        }
+        if (token.kind === "identifier" && token.text === "def" && isPunct(stream, index + 2, "(")) {
+            const close = stream.match[index + 2];
+            for (let cursor = index + 3; cursor < close; cursor += 1) {
+                const parameter = stream.toks[cursor];
+                const before = stream.toks[cursor - 1];
+                if (parameter.kind === "identifier" && before.kind === "punctuator" && (before.text === "(" || before.text === "," || before.text === "*" || before.text === "**"))
+                    parameters.add(parameter.text);
+            }
+        }
+    }
+    for (let index = first; index <= last; index += 1) {
+        const token = stream.toks[index];
+        if (token.kind !== "identifier")
+            continue;
+        if (layout.stmtStart[index] === index && assignmentTarget(index) === token.text && !globals.has(token.text))
+            locals.add(token.text);
+        if (isIdent(stream, index - 1, "for") || isIdent(stream, index - 1, "as"))
+            locals.add(token.text);
+    }
+    const qualifierNames = new Set([...classNames, "cls"]);
+    const record = (index, name) => {
+        out.sharedState.push({ line: lineOf(stream, index), name });
+    };
+    const isAssignment = (index) => {
+        const token = stream.toks[index];
+        return token !== undefined && token.kind === "punctuator" && ASSIGNMENT_TOKENS.has(token.text);
+    };
+    for (let index = first; index <= last; index += 1) {
+        const token = stream.toks[index];
+        if (token.kind !== "identifier")
+            continue;
+        const previous = stream.toks[index - 1];
+        const owner = previous !== undefined && previous.kind === "punctuator" && previous.text === "." ? stream.toks[index - 2] : undefined;
+        if (owner === undefined) {
+            if (!moduleNames.has(token.text) || parameters.has(token.text))
+                continue;
+            const chain = parseChain(stream, index, CHAIN_OPTIONS);
+            if (chain.segments[0].open >= 0)
+                continue;
+            const lastSegment = chain.segments[chain.segments.length - 1];
+            const bare = chain.end === index;
+            const assigned = isAssignment(chain.end + 1);
+            const mutatorCall = chain.segments.length > 1 && lastSegment.open >= 0 && MUTATORS.has(lastSegment.name);
+            if (bare && assigned) {
+                if (globals.has(token.text))
+                    record(index, token.text);
+            }
+            else if ((mutatorCall || (!bare && assigned)) && !locals.has(token.text))
+                record(index, token.text);
+            continue;
+        }
+        if (owner.kind !== "identifier")
+            continue;
+        const viaSelf = owner.text === "self";
+        if (!viaSelf && !qualifierNames.has(owner.text))
+            continue;
+        if (!classAttributes.has(token.text))
+            continue;
+        const chain = parseChain(stream, index, CHAIN_OPTIONS);
+        if (chain.segments[0].open >= 0)
+            continue;
+        const lastSegment = chain.segments[chain.segments.length - 1];
+        const assigned = isAssignment(chain.end + 1);
+        const mutatorCall = chain.segments.length > 1 && lastSegment.open >= 0 && MUTATORS.has(lastSegment.name);
+        if (viaSelf ? mutatorCall || (chain.end > index && assigned) : mutatorCall || assigned)
+            record(index, token.text);
+    }
+}
+//# sourceMappingURL=python-family.js.map