@mnemonica/tactica 0.1.14 → 0.2.0

package/lib/scopes.js

@@ -0,0 +1,582 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalScopeWalker = void 0;
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const ASSIGNMENT_OPERATORS = new Set([
+    ts.SyntaxKind.EqualsToken,
+    ts.SyntaxKind.PlusEqualsToken,
+    ts.SyntaxKind.MinusEqualsToken,
+    ts.SyntaxKind.AsteriskEqualsToken,
+    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+    ts.SyntaxKind.SlashEqualsToken,
+    ts.SyntaxKind.PercentEqualsToken,
+    ts.SyntaxKind.LessThanLessThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.AmpersandEqualsToken,
+    ts.SyntaxKind.BarEqualsToken,
+    ts.SyntaxKind.CaretEqualsToken,
+    ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+    ts.SyntaxKind.BarBarEqualsToken,
+    ts.SyntaxKind.QuestionQuestionEqualsToken,
+]);
+/**
+ * Local-scope walker (instrumentation walker plan, Phase 2).
+ *
+ * Tracks function/method/arrow scopes ONLY (decision 5: no block scopes),
+ * plus one synthetic 'module' scope per file — the plan requires module-scope
+ * instance creations to be labeled, not dropped. Variables carry isMutable
+ * (const vs let/var/parameter) and `reassignments`: each reassignment site of
+ * a mutable binding is a flow-termination point (decision 6) — downstream the
+ * walker stops following that binding there.
+ *
+ * Usage: addFile() per source file, then build(resolver) once definitions are
+ * known. findHolderScopeId(location) maps a usage location string to the
+ * innermost scope containing it (usages.json holderScopeId).
+ */
+class LocalScopeWalker {
+    constructor() {
+        this.scopes = new Map();
+        this.spans = new Map();
+        this.variables = new Map();
+        this.pending = [];
+        /**
+         * Arrow/function-expression node -> name it is bound to (`const f = () => …`,
+         * `{ handler: () => … }`, class properties). Program source files can be
+         * UNBOUND (no node.parent pointers), so binding names travel through this
+         * map instead of parent lookups.
+         */
+        this.boundNames = new Map();
+    }
+    /**
+     * Track one source file. Re-adding the same file replaces its records,
+     * so a walker may safely be reused across passes.
+     */
+    addFile(sourceFile) {
+        const filePath = path.resolve(sourceFile.fileName);
+        this.dropFile(filePath);
+        const moduleScope = {
+            scopeId: filePath,
+            name: filePath,
+            kind: 'module',
+            filePath,
+            location: `${filePath}:1:1`,
+        };
+        this.scopes.set(moduleScope.scopeId, moduleScope);
+        const spans = [];
+        this.spans.set(filePath, spans);
+        spans.push(this.spanOf(sourceFile, sourceFile, moduleScope.scopeId));
+        const scopeStack = [moduleScope.scopeId];
+        const classStack = [];
+        this.visitNode(sourceFile, sourceFile, filePath, scopeStack, classStack, spans);
+    }
+    /**
+     * Resolve pending typePaths and return the analysis.
+     */
+    build(resolver) {
+        if (resolver) {
+            for (const entry of this.pending) {
+                const typePath = this.resolveVariableTypePath(entry, resolver);
+                if (typePath) {
+                    entry.variable.typePath = typePath;
+                }
+            }
+        }
+        const analysis = {
+            scopes: this.scopes,
+            variables: this.variables,
+        };
+        return analysis;
+    }
+    /**
+     * Map a usage location string ('abs/file.ts:line:col') to the innermost
+     * scope containing it. Module scope is the fallback, so every location
+     * inside a tracked file resolves to some scope.
+     */
+    findHolderScopeId(location) {
+        const lastColon = location.lastIndexOf(':');
+        const prevColon = location.lastIndexOf(':', lastColon - 1);
+        if (lastColon < 0 || prevColon < 0) {
+            return undefined;
+        }
+        const filePath = path.resolve(location.slice(0, prevColon));
+        const line = Number(location.slice(prevColon + 1, lastColon));
+        const col = Number(location.slice(lastColon + 1));
+        if (!Number.isFinite(line) || !Number.isFinite(col)) {
+            return undefined;
+        }
+        const spans = this.spans.get(filePath);
+        if (!spans) {
+            return undefined;
+        }
+        let best;
+        for (const span of spans) {
+            const startsBefore = span.startLine < line || (span.startLine === line && span.startCol <= col);
+            const endsAfter = span.endLine > line || (span.endLine === line && span.endCol >= col);
+            if (!startsBefore || !endsAfter) {
+                continue;
+            }
+            // Innermost = smallest containing span
+            if (best && (best.startLine < span.startLine ||
+                (best.startLine === span.startLine && best.startCol <= span.startCol))) {
+                best = span;
+                continue;
+            }
+            if (!best) {
+                best = span;
+            }
+        }
+        const result = best?.scopeId;
+        return result;
+    }
+    /**
+     * Remove every record belonging to one file (re-add support).
+     */
+    dropFile(filePath) {
+        for (const [scopeId, scope] of this.scopes) {
+            if (scope.filePath === filePath) {
+                this.scopes.delete(scopeId);
+            }
+        }
+        for (const key of Array.from(this.variables.keys())) {
+            if (key.startsWith(`${filePath}#`) || key.startsWith(`${filePath}:`)) {
+                this.variables.delete(key);
+            }
+        }
+        this.pending = this.pending.filter(entry => !entry.variable.declaration.startsWith(`${filePath}:`));
+        this.spans.delete(filePath);
+    }
+    /**
+     * Attach holderScopeId to every usage whose location falls inside a
+     * tracked scope. Additive on UsageInfo; usages outside tracked files
+     * are left untouched.
+     */
+    static attachHolderScopeIds(usages, walker) {
+        for (const usageList of usages.values()) {
+            for (const usage of usageList) {
+                const scopeId = walker.findHolderScopeId(usage.location);
+                if (scopeId) {
+                    usage.holderScopeId = scopeId;
+                }
+            }
+        }
+    }
+    visitNode(node, sourceFile, filePath, scopeStack, classStack, spans) {
+        const scopeKind = LocalScopeWalker.scopeKindOf(node);
+        let entered = false;
+        if (scopeKind && this.hasBody(node)) {
+            this.enterScope(node, scopeKind, sourceFile, filePath, scopeStack, classStack, spans);
+            entered = true;
+        }
+        const isClass = ts.isClassDeclaration(node) || ts.isClassExpression(node);
+        if (isClass) {
+            classStack.push(node.name?.text ?? '');
+        }
+        this.collectBoundName(node);
+        this.collectVariableDeclarationList(node, sourceFile, scopeStack);
+        this.collectReassignment(node, sourceFile, scopeStack);
+        ts.forEachChild(node, child => {
+            this.visitNode(child, sourceFile, filePath, scopeStack, classStack, spans);
+        });
+        if (isClass) {
+            classStack.pop();
+        }
+        if (entered) {
+            scopeStack.pop();
+        }
+    }
+    static scopeKindOf(node) {
+        if (ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) ||
+            ts.isSetAccessorDeclaration(node) || ts.isConstructorDeclaration(node)) {
+            return 'method';
+        }
+        if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+            return 'function';
+        }
+        if (ts.isArrowFunction(node)) {
+            return 'arrow';
+        }
+        return undefined;
+    }
+    hasBody(node) {
+        const bodyHolder = node;
+        const result = bodyHolder.body !== undefined;
+        return result;
+    }
+    enterScope(node, kind, sourceFile, filePath, scopeStack, classStack, spans) {
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const scopeId = `${filePath}:${line + 1}:${character + 1}`;
+        const parentScopeId = scopeStack[scopeStack.length - 1];
+        const scope = {
+            scopeId,
+            name: this.scopeName(node, kind, filePath, line + 1, classStack),
+            kind,
+            parentScopeId,
+            filePath,
+            location: scopeId,
+        };
+        this.scopes.set(scopeId, scope);
+        spans.push(this.spanOf(node, sourceFile, scopeId));
+        scopeStack.push(scopeId);
+        // Parameters are variables of the scope; they are reassignable, so
+        // isMutable: true — a parameter reassignment terminates the flow too
+        const fn = node;
+        for (const param of fn.parameters ?? []) {
+            if (!ts.isIdentifier(param.name)) {
+                // Skip destructured parameters (analyzer precedent)
+                continue;
+            }
+            this.recordVariable(param.name.text, param.name, sourceFile, scopeStack, {
+                isParameter: true,
+                // `this` parameters (mnemonica handlers) are never reassignable
+                isMutable: param.name.text !== 'this',
+                annotation: param.type?.getText(sourceFile),
+            });
+        }
+    }
+    /**
+     * Decision 8 labeling: functions by name; methods as Class.method;
+     * arrows/functions bound to a variable or property take that name;
+     * anonymous holders are labeled file:line.
+     */
+    scopeName(node, kind, filePath, line, classStack) {
+        const named = node;
+        if (kind === 'method') {
+            const methodName = named.name ? named.name.getText() : 'anonymous';
+            const className = classStack[classStack.length - 1];
+            const ctor = ts.isConstructorDeclaration(node) ? 'constructor' : methodName;
+            const methodScopeName = className ? `${className}.${ctor}` : ctor;
+            return methodScopeName;
+        }
+        if (named.name && ts.isIdentifier(named.name)) {
+            const declaredName = named.name.text;
+            return declaredName;
+        }
+        // Bound names come from the boundNames map — program files may be
+        // unbound, so node.parent is not a reliable path to the variable name
+        const bound = this.boundNames.get(node);
+        if (bound) {
+            return bound;
+        }
+        const result = `${filePath}:${line}`;
+        return result;
+    }
+    spanOf(node, sourceFile, scopeId) {
+        const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+        const span = {
+            scopeId,
+            startLine: start.line + 1,
+            startCol: start.character + 1,
+            endLine: end.line + 1,
+            endCol: end.character + 1,
+        };
+        return span;
+    }
+    /**
+     * Record the name an arrow/function-expression is bound to, without
+     * relying on node.parent (unbound program files): `const f = () => …`,
+     * `{ handler: () => … }`, `class C { run = () => … }`.
+     */
+    collectBoundName(node) {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer &&
+            (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+            this.boundNames.set(node.initializer, node.name.text);
+            return;
+        }
+        if ((ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)) &&
+            ts.isIdentifier(node.name) && node.initializer &&
+            (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+            this.boundNames.set(node.initializer, node.name.text);
+        }
+    }
+    collectVariableDeclarationList(node, sourceFile, scopeStack) {
+        if (!ts.isVariableDeclarationList(node)) {
+            return;
+        }
+        // Flags live on the list itself — no parent walk needed (the list's
+        // parent may be unset on unbound program files)
+        const isConst = (node.flags & ts.NodeFlags.Const) !== 0;
+        for (const decl of node.declarations) {
+            // Destructuring declarations are skipped: only plain
+            // `const/let/var x = …` has an identifier name
+            if (!ts.isIdentifier(decl.name)) {
+                continue;
+            }
+            this.recordVariable(decl.name.text, decl.name, sourceFile, scopeStack, {
+                isParameter: false,
+                isMutable: !isConst,
+                annotation: decl.type?.getText(sourceFile),
+                initializer: decl.initializer,
+            });
+        }
+    }
+    recordVariable(name, node, sourceFile, scopeStack, options) {
+        const scopeId = scopeStack[scopeStack.length - 1];
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const filePath = path.resolve(sourceFile.fileName);
+        const variable = {
+            name,
+            scopeId,
+            declaration: `${filePath}:${line + 1}:${character + 1}`,
+            isParameter: options.isParameter,
+            isMutable: options.isMutable,
+            reassignments: [],
+        };
+        const inferred = options.annotation ?? (options.initializer ? LocalScopeWalker.inferInitializerKind(options.initializer) : undefined);
+        if (inferred) {
+            variable.inferredType = inferred;
+        }
+        const pendingEntry = {
+            variable,
+            scopeChain: [...scopeStack].reverse(),
+            annotation: options.annotation,
+        };
+        const { initializer } = options;
+        if (initializer && ts.isNewExpression(initializer)) {
+            const { expression } = initializer;
+            if (ts.isIdentifier(expression)) {
+                pendingEntry.newName = expression.text;
+            }
+            else if (ts.isPropertyAccessExpression(expression)) {
+                const chain = LocalScopeWalker.unwrapPropertyAccess(expression);
+                if (chain.length > 1) {
+                    const [root, ...rest] = chain;
+                    pendingEntry.newChainRoot = root;
+                    pendingEntry.newChainRest = rest;
+                }
+            }
+        }
+        if (initializer && ts.isCallExpression(initializer)) {
+            const lookup = LocalScopeWalker.unwrapLookupCall(initializer);
+            if (lookup) {
+                pendingEntry.lookupPath = lookup.path;
+                pendingEntry.lookupReceiver = lookup.receiver;
+            }
+        }
+        this.pending.push(pendingEntry);
+        this.variables.set(`${scopeId}#${name}`, variable);
+    }
+    /**
+     * `a.b.c` → ['a', 'b', 'c'] (left-to-right); undefined-safe for
+     * non-identifier roots.
+     */
+    static unwrapPropertyAccess(expression) {
+        const chain = [];
+        let current = expression;
+        while (ts.isPropertyAccessExpression(current)) {
+            chain.unshift(current.name.text);
+            current = current.expression;
+        }
+        if (ts.isIdentifier(current)) {
+            chain.unshift(current.text);
+        }
+        return chain;
+    }
+    /**
+     * `lookup('A.B')`, `App.lookup('A.B')`, `lookup(source, 'A.B')` → the
+     * string-literal path plus the receiver's root identifier when there is
+     * one. Only literal paths are tracked: a computed path is data the static
+     * walker cannot follow, so it is skipped (the analyzer's usage pass still
+     * records the lookup call itself).
+     */
+    static unwrapLookupCall(call) {
+        const { expression } = call;
+        const [firstArg, secondArg] = call.arguments;
+        if (ts.isIdentifier(expression)) {
+            if (expression.text !== 'lookup') {
+                return undefined;
+            }
+            // lookup('A.B')
+            if (firstArg && ts.isStringLiteralLike(firstArg)) {
+                const result = { path: firstArg.text };
+                return result;
+            }
+            // lookup(source, 'A.B') — explicit-source form
+            if (firstArg && ts.isIdentifier(firstArg) && secondArg && ts.isStringLiteralLike(secondArg)) {
+                const result = { path: secondArg.text, receiver: firstArg.text };
+                return result;
+            }
+            return undefined;
+        }
+        if (ts.isPropertyAccessExpression(expression) && expression.name.text === 'lookup') {
+            if (!firstArg || !ts.isStringLiteralLike(firstArg)) {
+                return undefined;
+            }
+            const chain = LocalScopeWalker.unwrapPropertyAccess(expression);
+            // chain < 2 means no identifier receiver (e.g. this.lookup('A.B'))
+            if (chain.length < 2) {
+                const pathOnly = { path: firstArg.text };
+                return pathOnly;
+            }
+            const [receiver] = chain;
+            const result = { path: firstArg.text, receiver };
+            return result;
+        }
+        return undefined;
+    }
+    /**
+     * Cheap initializer classification for inferredType. Deliberately tiny:
+     * literal kinds and `new X` constructor names; everything else undefined.
+     */
+    static inferInitializerKind(initializer) {
+        if (ts.isStringLiteralLike(initializer) || ts.isTemplateExpression(initializer)) {
+            return 'string';
+        }
+        if (ts.isNumericLiteral(initializer)) {
+            return 'number';
+        }
+        if (initializer.kind === ts.SyntaxKind.TrueKeyword || initializer.kind === ts.SyntaxKind.FalseKeyword) {
+            return 'boolean';
+        }
+        if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
+            return 'function';
+        }
+        if (ts.isArrayLiteralExpression(initializer)) {
+            return 'Array<unknown>';
+        }
+        if (ts.isNewExpression(initializer) && ts.isIdentifier(initializer.expression)) {
+            const result = initializer.expression.text;
+            return result;
+        }
+        return undefined;
+    }
+    /**
+     * Reassignment of a let/var/parameter binding: a flow-termination point
+     * (decision 6). Recorded on the variable so the Phase 3 walker stops
+     * following that binding there.
+     */
+    collectReassignment(node, sourceFile, scopeStack) {
+        let target;
+        if (ts.isBinaryExpression(node) &&
+            ASSIGNMENT_OPERATORS.has(node.operatorToken.kind) &&
+            ts.isIdentifier(node.left)) {
+            target = node.left;
+        }
+        if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+            (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) &&
+            ts.isIdentifier(node.operand)) {
+            target = node.operand;
+        }
+        if (!target) {
+            return;
+        }
+        // Note: a declaration initializer (`let x = 5`) is a VariableDeclaration,
+        // never a BinaryExpression, so it cannot reach this path as a "reassignment"
+        const variable = this.findVariable(target.text, scopeStack);
+        if (!variable) {
+            return;
+        }
+        const filePath = path.resolve(sourceFile.fileName);
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(target.getStart(sourceFile));
+        variable.reassignments.push(`${filePath}:${line + 1}:${character + 1}`);
+    }
+    /**
+     * Find a variable by name walking the scope chain outward.
+     */
+    findVariable(name, scopeStack) {
+        for (let i = scopeStack.length - 1; i >= 0; i--) {
+            const variable = this.variables.get(`${scopeStack[i]}#${name}`);
+            if (variable) {
+                return variable;
+            }
+        }
+        return undefined;
+    }
+    resolveVariableTypePath(entry, resolver) {
+        // `new SomeType(...)` — bare constructor name
+        if (entry.newName) {
+            const resolved = resolver.resolveByName(entry.newName);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        // `new instance.Sub.Type(...)` — chain off a tracked variable's typePath
+        if (entry.newChainRoot && entry.newChainRest && entry.newChainRest.length > 0) {
+            for (const scopeId of entry.scopeChain) {
+                const rootVariable = this.variables.get(`${scopeId}#${entry.newChainRoot}`);
+                if (!rootVariable?.typePath) {
+                    continue;
+                }
+                const candidate = [rootVariable.typePath, ...entry.newChainRest].join('.');
+                if (resolver.hasPath(candidate)) {
+                    return candidate;
+                }
+            }
+        }
+        // `lookup('A.B')` / `receiver.lookup('A.B')` initializers
+        if (entry.lookupPath) {
+            // Receiver-relative first: `user.lookup('AdminEntity')` resolves
+            // against the receiver variable's typePath when that yields a
+            // known path (mirrors the analyzer's relative-then-root rule)
+            if (entry.lookupReceiver) {
+                for (const scopeId of entry.scopeChain) {
+                    const receiverVariable = this.variables.get(`${scopeId}#${entry.lookupReceiver}`);
+                    if (!receiverVariable?.typePath) {
+                        continue;
+                    }
+                    const candidate = `${receiverVariable.typePath}.${entry.lookupPath}`;
+                    if (resolver.hasPath(candidate)) {
+                        return candidate;
+                    }
+                }
+            }
+            if (resolver.hasPath(entry.lookupPath)) {
+                return entry.lookupPath;
+            }
+            const byName = resolver.resolveByName(entry.lookupPath);
+            if (byName) {
+                return byName;
+            }
+        }
+        // Type annotation: 'UserEntity_UserResponse' (tactica types.ts naming)
+        // → dotted path, or a bare known type name
+        if (entry.annotation) {
+            const dotted = entry.annotation.replace(/_/g, '.');
+            if (dotted.includes('.') && resolver.hasPath(dotted)) {
+                return dotted;
+            }
+            const byName = resolver.resolveByName(entry.annotation);
+            if (byName) {
+                return byName;
+            }
+        }
+        return undefined;
+    }
+}
+exports.LocalScopeWalker = LocalScopeWalker;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scopes.js","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"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","sourcesContent":["'use strict';\n\nimport * as path from 'path';\nimport * as ts from 'typescript';\nimport {\n\tScopeAnalysis, ScopeInfo, ScopeKind, ScopeVariable, UsageInfo\n} from './types';\n\n/**\n * Compile-time view over the analyzer's definitions, used to attach mnemonica\n * type paths to variables. Name-based heuristics only — the no-getTypeChecker()\n * precedent stays.\n */\nexport interface ScopeTypeResolver {\n\t/** Resolve a bare constructor/type name to a mnemonica fullPath (undefined when unknown or ambiguous) */\n\tresolveByName(name: string): string | undefined;\n\t/** True when the dotted path is a known mnemonica type */\n\thasPath(fullPath: string): boolean;\n}\n\n/**\n * Internal scope record: numeric span (1-based line/col) kept for\n * findHolderScopeId() containment matching; ScopeInfo itself carries strings.\n */\ninterface ScopeSpan {\n\tscopeId: string;\n\tstartLine: number;\n\tstartCol: number;\n\tendLine: number;\n\tendCol: number;\n}\n\n/**\n * Raw variable record collected during the AST walk. typePath is resolved\n * later in build(), once definitions are known.\n */\ninterface PendingVariable {\n\tvariable: ScopeVariable;\n\t/** Bare constructor name for `new X(...)` initializers */\n\tnewName?: string;\n\t/** Root identifier + property chain for `new a.b.C(...)` initializers */\n\tnewChainRoot?: string;\n\tnewChainRest?: string[];\n\t/** String-literal path of a `lookup('A.B')` initializer */\n\tlookupPath?: string;\n\t/** Root identifier of the receiver for `receiver.lookup('A.B')` / `lookup(source, 'A.B')` */\n\tlookupReceiver?: string;\n\t/** Raw type annotation text (e.g. 'UserEntity_UserResponse') */\n\tannotation?: string;\n\t/** Scope chain from declaration site outward, for chain-root lookup */\n\tscopeChain: string[];\n}\n\nconst ASSIGNMENT_OPERATORS = new Set<ts.SyntaxKind>([\n\tts.SyntaxKind.EqualsToken,\n\tts.SyntaxKind.PlusEqualsToken,\n\tts.SyntaxKind.MinusEqualsToken,\n\tts.SyntaxKind.AsteriskEqualsToken,\n\tts.SyntaxKind.AsteriskAsteriskEqualsToken,\n\tts.SyntaxKind.SlashEqualsToken,\n\tts.SyntaxKind.PercentEqualsToken,\n\tts.SyntaxKind.LessThanLessThanEqualsToken,\n\tts.SyntaxKind.GreaterThanGreaterThanEqualsToken,\n\tts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,\n\tts.SyntaxKind.AmpersandEqualsToken,\n\tts.SyntaxKind.BarEqualsToken,\n\tts.SyntaxKind.CaretEqualsToken,\n\tts.SyntaxKind.AmpersandAmpersandEqualsToken,\n\tts.SyntaxKind.BarBarEqualsToken,\n\tts.SyntaxKind.QuestionQuestionEqualsToken,\n]);\n\n/**\n * Local-scope walker (instrumentation walker plan, Phase 2).\n *\n * Tracks function/method/arrow scopes ONLY (decision 5: no block scopes),\n * plus one synthetic 'module' scope per file — the plan requires module-scope\n * instance creations to be labeled, not dropped. Variables carry isMutable\n * (const vs let/var/parameter) and `reassignments`: each reassignment site of\n * a mutable binding is a flow-termination point (decision 6) — downstream the\n * walker stops following that binding there.\n *\n * Usage: addFile() per source file, then build(resolver) once definitions are\n * known. findHolderScopeId(location) maps a usage location string to the\n * innermost scope containing it (usages.json holderScopeId).\n */\nexport class LocalScopeWalker {\n\tprivate scopes = new Map<string, ScopeInfo>();\n\tprivate spans = new Map<string, ScopeSpan[]>();\n\tprivate variables = new Map<string, ScopeVariable>();\n\tprivate pending: PendingVariable[] = [];\n\t/**\n\t * Arrow/function-expression node -> name it is bound to (`const f = () => …`,\n\t * `{ handler: () => … }`, class properties). Program source files can be\n\t * UNBOUND (no node.parent pointers), so binding names travel through this\n\t * map instead of parent lookups.\n\t */\n\tprivate boundNames = new Map<ts.Node, string>();\n\n\t/**\n\t * Track one source file. Re-adding the same file replaces its records,\n\t * so a walker may safely be reused across passes.\n\t */\n\taddFile (sourceFile: ts.SourceFile): void {\n\t\tconst filePath = path.resolve(sourceFile.fileName);\n\t\tthis.dropFile(filePath);\n\n\t\tconst moduleScope: ScopeInfo = {\n\t\t\tscopeId  : filePath,\n\t\t\tname     : filePath,\n\t\t\tkind     : 'module',\n\t\t\tfilePath,\n\t\t\tlocation : `${filePath}:1:1`,\n\t\t};\n\t\tthis.scopes.set(moduleScope.scopeId, moduleScope);\n\n\t\tconst spans: ScopeSpan[] = [];\n\t\tthis.spans.set(filePath, spans);\n\t\tspans.push(this.spanOf(sourceFile, sourceFile, moduleScope.scopeId));\n\n\t\tconst scopeStack: string[] = [ moduleScope.scopeId ];\n\t\tconst classStack: string[] = [];\n\t\tthis.visitNode(sourceFile, sourceFile, filePath, scopeStack, classStack, spans);\n\t}\n\n\t/**\n\t * Resolve pending typePaths and return the analysis.\n\t */\n\tbuild (resolver?: ScopeTypeResolver): ScopeAnalysis {\n\t\tif (resolver) {\n\t\t\tfor (const entry of this.pending) {\n\t\t\t\tconst typePath = this.resolveVariableTypePath(entry, resolver);\n\t\t\t\tif (typePath) {\n\t\t\t\t\tentry.variable.typePath = typePath;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst analysis: ScopeAnalysis = {\n\t\t\tscopes    : this.scopes,\n\t\t\tvariables : this.variables,\n\t\t};\n\t\treturn analysis;\n\t}\n\n\t/**\n\t * Map a usage location string ('abs/file.ts:line:col') to the innermost\n\t * scope containing it. Module scope is the fallback, so every location\n\t * inside a tracked file resolves to some scope.\n\t */\n\tfindHolderScopeId (location: string): string | undefined {\n\t\tconst lastColon = location.lastIndexOf(':');\n\t\tconst prevColon = location.lastIndexOf(':', lastColon - 1);\n\t\tif (lastColon < 0 || prevColon < 0) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst filePath = path.resolve(location.slice(0, prevColon));\n\t\tconst line = Number(location.slice(prevColon + 1, lastColon));\n\t\tconst col = Number(location.slice(lastColon + 1));\n\t\tif (!Number.isFinite(line) || !Number.isFinite(col)) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst spans = this.spans.get(filePath);\n\t\tif (!spans) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tlet best: ScopeSpan | undefined;\n\t\tfor (const span of spans) {\n\t\t\tconst startsBefore = span.startLine < line || (span.startLine === line && span.startCol <= col);\n\t\t\tconst endsAfter = span.endLine > line || (span.endLine === line && span.endCol >= col);\n\t\t\tif (!startsBefore || !endsAfter) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\t// Innermost = smallest containing span\n\t\t\tif (best && (best.startLine < span.startLine ||\n\t\t\t\t(best.startLine === span.startLine && best.startCol <= span.startCol))) {\n\t\t\t\tbest = span;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (!best) {\n\t\t\t\tbest = span;\n\t\t\t}\n\t\t}\n\t\tconst result = best?.scopeId;\n\t\treturn result;\n\t}\n\n\t/**\n\t * Remove every record belonging to one file (re-add support).\n\t */\n\tprivate dropFile (filePath: string): void {\n\t\tfor (const [ scopeId, scope ] of this.scopes) {\n\t\t\tif (scope.filePath === filePath) {\n\t\t\t\tthis.scopes.delete(scopeId);\n\t\t\t}\n\t\t}\n\t\tfor (const key of Array.from(this.variables.keys())) {\n\t\t\tif (key.startsWith(`${filePath}#`) || key.startsWith(`${filePath}:`)) {\n\t\t\t\tthis.variables.delete(key);\n\t\t\t}\n\t\t}\n\t\tthis.pending = this.pending.filter(entry =>\n\t\t\t!entry.variable.declaration.startsWith(`${filePath}:`));\n\t\tthis.spans.delete(filePath);\n\t}\n\n\t/**\n\t * Attach holderScopeId to every usage whose location falls inside a\n\t * tracked scope. Additive on UsageInfo; usages outside tracked files\n\t * are left untouched.\n\t */\n\tstatic attachHolderScopeIds (usages: Map<string, UsageInfo[]>, walker: LocalScopeWalker): void {\n\t\tfor (const usageList of usages.values()) {\n\t\t\tfor (const usage of usageList) {\n\t\t\t\tconst scopeId = walker.findHolderScopeId(usage.location);\n\t\t\t\tif (scopeId) {\n\t\t\t\t\tusage.holderScopeId = scopeId;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate visitNode (\n\t\tnode: ts.Node,\n\t\tsourceFile: ts.SourceFile,\n\t\tfilePath: string,\n\t\tscopeStack: string[],\n\t\tclassStack: string[],\n\t\tspans: ScopeSpan[]\n\t): void {\n\t\tconst scopeKind = LocalScopeWalker.scopeKindOf(node);\n\t\tlet entered = false;\n\t\tif (scopeKind && this.hasBody(node)) {\n\t\t\tthis.enterScope(node, scopeKind, sourceFile, filePath, scopeStack, classStack, spans);\n\t\t\tentered = true;\n\t\t}\n\n\t\tconst isClass = ts.isClassDeclaration(node) || ts.isClassExpression(node);\n\t\tif (isClass) {\n\t\t\tclassStack.push(node.name?.text ?? '');\n\t\t}\n\n\t\tthis.collectBoundName(node);\n\t\tthis.collectVariableDeclarationList(node, sourceFile, scopeStack);\n\t\tthis.collectReassignment(node, sourceFile, scopeStack);\n\n\t\tts.forEachChild(node, child => {\n\t\t\tthis.visitNode(child, sourceFile, filePath, scopeStack, classStack, spans);\n\t\t});\n\n\t\tif (isClass) {\n\t\t\tclassStack.pop();\n\t\t}\n\t\tif (entered) {\n\t\t\tscopeStack.pop();\n\t\t}\n\t}\n\n\tprivate static scopeKindOf (node: ts.Node): ScopeKind | undefined {\n\t\tif (ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) ||\n\t\t\tts.isSetAccessorDeclaration(node) || ts.isConstructorDeclaration(node)) {\n\t\t\treturn 'method';\n\t\t}\n\t\tif (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {\n\t\t\treturn 'function';\n\t\t}\n\t\tif (ts.isArrowFunction(node)) {\n\t\t\treturn 'arrow';\n\t\t}\n\t\treturn undefined;\n\t}\n\n\tprivate hasBody (node: ts.Node): boolean {\n\t\tconst bodyHolder = node as ts.FunctionLikeDeclaration;\n\t\tconst result = bodyHolder.body !== undefined;\n\t\treturn result;\n\t}\n\n\tprivate enterScope (\n\t\tnode: ts.Node,\n\t\tkind: ScopeKind,\n\t\tsourceFile: ts.SourceFile,\n\t\tfilePath: string,\n\t\tscopeStack: string[],\n\t\tclassStack: string[],\n\t\tspans: ScopeSpan[]\n\t): void {\n\t\tconst { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));\n\t\tconst scopeId = `${filePath}:${line + 1}:${character + 1}`;\n\t\tconst parentScopeId = scopeStack[ scopeStack.length - 1 ];\n\n\t\tconst scope: ScopeInfo = {\n\t\t\tscopeId,\n\t\t\tname     : this.scopeName(node, kind, filePath, line + 1, classStack),\n\t\t\tkind,\n\t\t\tparentScopeId,\n\t\t\tfilePath,\n\t\t\tlocation : scopeId,\n\t\t};\n\t\tthis.scopes.set(scopeId, scope);\n\t\tspans.push(this.spanOf(node, sourceFile, scopeId));\n\t\tscopeStack.push(scopeId);\n\n\t\t// Parameters are variables of the scope; they are reassignable, so\n\t\t// isMutable: true — a parameter reassignment terminates the flow too\n\t\tconst fn = node as ts.FunctionLikeDeclaration;\n\t\tfor (const param of fn.parameters ?? []) {\n\t\t\tif (!ts.isIdentifier(param.name)) {\n\t\t\t\t// Skip destructured parameters (analyzer precedent)\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tthis.recordVariable(param.name.text, param.name, sourceFile, scopeStack, {\n\t\t\t\tisParameter : true,\n\t\t\t\t// `this` parameters (mnemonica handlers) are never reassignable\n\t\t\t\tisMutable   : param.name.text !== 'this',\n\t\t\t\tannotation  : param.type?.getText(sourceFile),\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Decision 8 labeling: functions by name; methods as Class.method;\n\t * arrows/functions bound to a variable or property take that name;\n\t * anonymous holders are labeled file:line.\n\t */\n\tprivate scopeName (\n\t\tnode: ts.Node,\n\t\tkind: ScopeKind,\n\t\tfilePath: string,\n\t\tline: number,\n\t\tclassStack: string[]\n\t): string {\n\t\tconst named = node as ts.NamedDeclaration;\n\t\tif (kind === 'method') {\n\t\t\tconst methodName = named.name ? named.name.getText() : 'anonymous';\n\t\t\tconst className = classStack[ classStack.length - 1 ];\n\t\t\tconst ctor = ts.isConstructorDeclaration(node) ? 'constructor' : methodName;\n\t\t\tconst methodScopeName = className ? `${className}.${ctor}` : ctor;\n\t\t\treturn methodScopeName;\n\t\t}\n\t\tif (named.name && ts.isIdentifier(named.name)) {\n\t\t\tconst declaredName = named.name.text;\n\t\t\treturn declaredName;\n\t\t}\n\t\t// Bound names come from the boundNames map — program files may be\n\t\t// unbound, so node.parent is not a reliable path to the variable name\n\t\tconst bound = this.boundNames.get(node);\n\t\tif (bound) {\n\t\t\treturn bound;\n\t\t}\n\t\tconst result = `${filePath}:${line}`;\n\t\treturn result;\n\t}\n\n\tprivate spanOf (\n\t\tnode: ts.Node,\n\t\tsourceFile: ts.SourceFile,\n\t\tscopeId: string\n\t): ScopeSpan {\n\t\tconst start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));\n\t\tconst end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());\n\t\tconst span: ScopeSpan = {\n\t\t\tscopeId,\n\t\t\tstartLine : start.line + 1,\n\t\t\tstartCol  : start.character + 1,\n\t\t\tendLine   : end.line + 1,\n\t\t\tendCol    : end.character + 1,\n\t\t};\n\t\treturn span;\n\t}\n\n\t/**\n\t * Record the name an arrow/function-expression is bound to, without\n\t * relying on node.parent (unbound program files): `const f = () => …`,\n\t * `{ handler: () => … }`, `class C { run = () => … }`.\n\t */\n\tprivate collectBoundName (node: ts.Node): void {\n\t\tif (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer &&\n\t\t\t(ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {\n\t\t\tthis.boundNames.set(node.initializer, node.name.text);\n\t\t\treturn;\n\t\t}\n\t\tif ((ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)) &&\n\t\t\tts.isIdentifier(node.name) && node.initializer &&\n\t\t\t(ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {\n\t\t\tthis.boundNames.set(node.initializer, node.name.text);\n\t\t}\n\t}\n\n\tprivate collectVariableDeclarationList (\n\t\tnode: ts.Node,\n\t\tsourceFile: ts.SourceFile,\n\t\tscopeStack: string[]\n\t): void {\n\t\tif (!ts.isVariableDeclarationList(node)) {\n\t\t\treturn;\n\t\t}\n\t\t// Flags live on the list itself — no parent walk needed (the list's\n\t\t// parent may be unset on unbound program files)\n\t\tconst isConst = (node.flags & ts.NodeFlags.Const) !== 0;\n\t\tfor (const decl of node.declarations) {\n\t\t\t// Destructuring declarations are skipped: only plain\n\t\t\t// `const/let/var x = …` has an identifier name\n\t\t\tif (!ts.isIdentifier(decl.name)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tthis.recordVariable(decl.name.text, decl.name, sourceFile, scopeStack, {\n\t\t\t\tisParameter : false,\n\t\t\t\tisMutable   : !isConst,\n\t\t\t\tannotation  : decl.type?.getText(sourceFile),\n\t\t\t\tinitializer : decl.initializer,\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate recordVariable (\n\t\tname: string,\n\t\tnode: ts.Node,\n\t\tsourceFile: ts.SourceFile,\n\t\tscopeStack: string[],\n\t\toptions: {\n\t\t\tisParameter: boolean;\n\t\t\tisMutable: boolean;\n\t\t\tannotation?: string;\n\t\t\tinitializer?: ts.Expression;\n\t\t}\n\t): void {\n\t\tconst scopeId = scopeStack[ scopeStack.length - 1 ];\n\t\tconst { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));\n\t\tconst filePath = path.resolve(sourceFile.fileName);\n\n\t\tconst variable: ScopeVariable = {\n\t\t\tname,\n\t\t\tscopeId,\n\t\t\tdeclaration   : `${filePath}:${line + 1}:${character + 1}`,\n\t\t\tisParameter   : options.isParameter,\n\t\t\tisMutable     : options.isMutable,\n\t\t\treassignments : [],\n\t\t};\n\t\tconst inferred = options.annotation ?? (\n\t\t\toptions.initializer ? LocalScopeWalker.inferInitializerKind(options.initializer) : undefined\n\t\t);\n\t\tif (inferred) {\n\t\t\tvariable.inferredType = inferred;\n\t\t}\n\n\t\tconst pendingEntry: PendingVariable = {\n\t\t\tvariable,\n\t\t\tscopeChain : [ ...scopeStack ].reverse(),\n\t\t\tannotation : options.annotation,\n\t\t};\n\t\tconst { initializer } = options;\n\t\tif (initializer && ts.isNewExpression(initializer)) {\n\t\t\tconst { expression } = initializer;\n\t\t\tif (ts.isIdentifier(expression)) {\n\t\t\t\tpendingEntry.newName = expression.text;\n\t\t\t} else if (ts.isPropertyAccessExpression(expression)) {\n\t\t\t\tconst chain = LocalScopeWalker.unwrapPropertyAccess(expression);\n\t\t\t\tif (chain.length > 1) {\n\t\t\t\t\tconst [ root, ...rest ] = chain;\n\t\t\t\t\tpendingEntry.newChainRoot = root;\n\t\t\t\t\tpendingEntry.newChainRest = rest;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (initializer && ts.isCallExpression(initializer)) {\n\t\t\tconst lookup = LocalScopeWalker.unwrapLookupCall(initializer);\n\t\t\tif (lookup) {\n\t\t\t\tpendingEntry.lookupPath = lookup.path;\n\t\t\t\tpendingEntry.lookupReceiver = lookup.receiver;\n\t\t\t}\n\t\t}\n\t\tthis.pending.push(pendingEntry);\n\t\tthis.variables.set(`${scopeId}#${name}`, variable);\n\t}\n\n\t/**\n\t * `a.b.c` → ['a', 'b', 'c'] (left-to-right); undefined-safe for\n\t * non-identifier roots.\n\t */\n\tprivate static unwrapPropertyAccess (expression: ts.PropertyAccessExpression): string[] {\n\t\tconst chain: string[] = [];\n\t\tlet current: ts.Expression = expression;\n\t\twhile (ts.isPropertyAccessExpression(current)) {\n\t\t\tchain.unshift(current.name.text);\n\t\t\tcurrent = current.expression;\n\t\t}\n\t\tif (ts.isIdentifier(current)) {\n\t\t\tchain.unshift(current.text);\n\t\t}\n\t\treturn chain;\n\t}\n\n\t/**\n\t * `lookup('A.B')`, `App.lookup('A.B')`, `lookup(source, 'A.B')` → the\n\t * string-literal path plus the receiver's root identifier when there is\n\t * one. Only literal paths are tracked: a computed path is data the static\n\t * walker cannot follow, so it is skipped (the analyzer's usage pass still\n\t * records the lookup call itself).\n\t */\n\tprivate static unwrapLookupCall (call: ts.CallExpression): { path: string; receiver?: string } | undefined {\n\t\tconst { expression } = call;\n\t\tconst [ firstArg, secondArg ] = call.arguments;\n\n\t\tif (ts.isIdentifier(expression)) {\n\t\t\tif (expression.text !== 'lookup') {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\t// lookup('A.B')\n\t\t\tif (firstArg && ts.isStringLiteralLike(firstArg)) {\n\t\t\t\tconst result = { path : firstArg.text };\n\t\t\t\treturn result;\n\t\t\t}\n\t\t\t// lookup(source, 'A.B') — explicit-source form\n\t\t\tif (firstArg && ts.isIdentifier(firstArg) && secondArg && ts.isStringLiteralLike(secondArg)) {\n\t\t\t\tconst result = { path : secondArg.text, receiver : firstArg.text };\n\t\t\t\treturn result;\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\n\t\tif (ts.isPropertyAccessExpression(expression) && expression.name.text === 'lookup') {\n\t\t\tif (!firstArg || !ts.isStringLiteralLike(firstArg)) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst chain = LocalScopeWalker.unwrapPropertyAccess(expression);\n\t\t\t// chain < 2 means no identifier receiver (e.g. this.lookup('A.B'))\n\t\t\tif (chain.length < 2) {\n\t\t\t\tconst pathOnly = { path : firstArg.text };\n\t\t\t\treturn pathOnly;\n\t\t\t}\n\t\t\tconst [ receiver ] = chain;\n\t\t\tconst result = { path : firstArg.text, receiver };\n\t\t\treturn result;\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Cheap initializer classification for inferredType. Deliberately tiny:\n\t * literal kinds and `new X` constructor names; everything else undefined.\n\t */\n\tprivate static inferInitializerKind (initializer: ts.Expression): string | undefined {\n\t\tif (ts.isStringLiteralLike(initializer) || ts.isTemplateExpression(initializer)) {\n\t\t\treturn 'string';\n\t\t}\n\t\tif (ts.isNumericLiteral(initializer)) {\n\t\t\treturn 'number';\n\t\t}\n\t\tif (initializer.kind === ts.SyntaxKind.TrueKeyword || initializer.kind === ts.SyntaxKind.FalseKeyword) {\n\t\t\treturn 'boolean';\n\t\t}\n\t\tif (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {\n\t\t\treturn 'function';\n\t\t}\n\t\tif (ts.isArrayLiteralExpression(initializer)) {\n\t\t\treturn 'Array<unknown>';\n\t\t}\n\t\tif (ts.isNewExpression(initializer) && ts.isIdentifier(initializer.expression)) {\n\t\t\tconst result = initializer.expression.text;\n\t\t\treturn result;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Reassignment of a let/var/parameter binding: a flow-termination point\n\t * (decision 6). Recorded on the variable so the Phase 3 walker stops\n\t * following that binding there.\n\t */\n\tprivate collectReassignment (\n\t\tnode: ts.Node,\n\t\tsourceFile: ts.SourceFile,\n\t\tscopeStack: string[]\n\t): void {\n\t\tlet target: ts.Identifier | undefined;\n\t\tif (ts.isBinaryExpression(node) &&\n\t\t\tASSIGNMENT_OPERATORS.has(node.operatorToken.kind) &&\n\t\t\tts.isIdentifier(node.left)) {\n\t\t\ttarget = node.left;\n\t\t}\n\t\tif ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&\n\t\t\t(node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) &&\n\t\t\tts.isIdentifier(node.operand)) {\n\t\t\ttarget = node.operand;\n\t\t}\n\t\tif (!target) {\n\t\t\treturn;\n\t\t}\n\t\t// Note: a declaration initializer (`let x = 5`) is a VariableDeclaration,\n\t\t// never a BinaryExpression, so it cannot reach this path as a \"reassignment\"\n\n\t\tconst variable = this.findVariable(target.text, scopeStack);\n\t\tif (!variable) {\n\t\t\treturn;\n\t\t}\n\t\tconst filePath = path.resolve(sourceFile.fileName);\n\t\tconst { line, character } = sourceFile.getLineAndCharacterOfPosition(target.getStart(sourceFile));\n\t\tvariable.reassignments.push(`${filePath}:${line + 1}:${character + 1}`);\n\t}\n\n\t/**\n\t * Find a variable by name walking the scope chain outward.\n\t */\n\tprivate findVariable (name: string, scopeStack: string[]): ScopeVariable | undefined {\n\t\tfor (let i = scopeStack.length - 1; i >= 0; i--) {\n\t\t\tconst variable = this.variables.get(`${scopeStack[ i ]}#${name}`);\n\t\t\tif (variable) {\n\t\t\t\treturn variable;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\tprivate resolveVariableTypePath (entry: PendingVariable, resolver: ScopeTypeResolver): string | undefined {\n\t\t// `new SomeType(...)` — bare constructor name\n\t\tif (entry.newName) {\n\t\t\tconst resolved = resolver.resolveByName(entry.newName);\n\t\t\tif (resolved) {\n\t\t\t\treturn resolved;\n\t\t\t}\n\t\t}\n\n\t\t// `new instance.Sub.Type(...)` — chain off a tracked variable's typePath\n\t\tif (entry.newChainRoot && entry.newChainRest && entry.newChainRest.length > 0) {\n\t\t\tfor (const scopeId of entry.scopeChain) {\n\t\t\t\tconst rootVariable = this.variables.get(`${scopeId}#${entry.newChainRoot}`);\n\t\t\t\tif (!rootVariable?.typePath) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst candidate = [ rootVariable.typePath, ...entry.newChainRest ].join('.');\n\t\t\t\tif (resolver.hasPath(candidate)) {\n\t\t\t\t\treturn candidate;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// `lookup('A.B')` / `receiver.lookup('A.B')` initializers\n\t\tif (entry.lookupPath) {\n\t\t\t// Receiver-relative first: `user.lookup('AdminEntity')` resolves\n\t\t\t// against the receiver variable's typePath when that yields a\n\t\t\t// known path (mirrors the analyzer's relative-then-root rule)\n\t\t\tif (entry.lookupReceiver) {\n\t\t\t\tfor (const scopeId of entry.scopeChain) {\n\t\t\t\t\tconst receiverVariable = this.variables.get(`${scopeId}#${entry.lookupReceiver}`);\n\t\t\t\t\tif (!receiverVariable?.typePath) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tconst candidate = `${receiverVariable.typePath}.${entry.lookupPath}`;\n\t\t\t\t\tif (resolver.hasPath(candidate)) {\n\t\t\t\t\t\treturn candidate;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (resolver.hasPath(entry.lookupPath)) {\n\t\t\t\treturn entry.lookupPath;\n\t\t\t}\n\t\t\tconst byName = resolver.resolveByName(entry.lookupPath);\n\t\t\tif (byName) {\n\t\t\t\treturn byName;\n\t\t\t}\n\t\t}\n\n\t\t// Type annotation: 'UserEntity_UserResponse' (tactica types.ts naming)\n\t\t// → dotted path, or a bare known type name\n\t\tif (entry.annotation) {\n\t\t\tconst dotted = entry.annotation.replace(/_/g, '.');\n\t\t\tif (dotted.includes('.') && resolver.hasPath(dotted)) {\n\t\t\t\treturn dotted;\n\t\t\t}\n\t\t\tconst byName = resolver.resolveByName(entry.annotation);\n\t\t\tif (byName) {\n\t\t\t\treturn byName;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n}\n"]}