gitnexus 1.4.0 → 1.4.5

package/dist/core/ingestion/type-env.js

@@ -1,26 +1,232 @@
-import { FUNCTION_NODE_TYPES, extractFunctionName } from './utils.js';
+import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES } from './utils.js';
 import { typeConfigs, TYPED_PARAMETER_TYPES } from './type-extractors/index.js';
+import { extractSimpleTypeName, extractVarName, stripNullable } from './type-extractors/shared.js';
 /** File-level scope key */
 const FILE_SCOPE = '';
+/** Fallback for languages where class names aren't in a 'name' field (e.g. Kotlin uses type_identifier). */
+const findTypeIdentifierChild = (node) => {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && child.type === 'type_identifier')
+            return child;
+    }
+    return null;
+};
+/** AST node types that represent mutually exclusive branch containers for pattern bindings. */
+const PATTERN_BRANCH_TYPES = new Set([
+    'when_entry', // Kotlin when
+    'switch_block_label', // Java switch (enhanced)
+]);
+/** Walk up the AST from a pattern node to find the enclosing branch container. */
+const findPatternBranchScope = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (PATTERN_BRANCH_TYPES.has(current.type))
+            return current;
+        if (FUNCTION_NODE_TYPES.has(current.type))
+            return undefined;
+        current = current.parent;
+    }
+    return undefined;
+};
+/** Bare nullable keywords that fastStripNullable must reject. */
+const FAST_NULLABLE_KEYWORDS = new Set(['null', 'undefined', 'void', 'None', 'nil']);
 /**
- * Look up a variable's type in the TypeEnv, trying the call's enclosing
- * function scope first, then falling back to file-level scope.
+ * Fast-path nullable check: 90%+ of type names are simple identifiers (e.g. "User")
+ * that don't need the full stripNullable parse. Only call stripNullable when the
+ * string contains nullable markers ('|' for union types, '?' for nullable suffix).
  */
-export const lookupTypeEnv = (env, varName, callNode) => {
+const fastStripNullable = (typeName) => {
+    if (FAST_NULLABLE_KEYWORDS.has(typeName))
+        return undefined;
+    return (typeName.indexOf('|') === -1 && typeName.indexOf('?') === -1)
+        ? typeName
+        : stripNullable(typeName);
+};
+/** Implementation of the lookup logic — shared between TypeEnvironment and the legacy export. */
+const lookupInEnv = (env, varName, callNode, patternOverrides) => {
+    // Self/this receiver: resolve to enclosing class name via AST walk
+    if (varName === 'self' || varName === 'this' || varName === '$this') {
+        return findEnclosingClassName(callNode);
+    }
+    // Super/base/parent receiver: resolve to the parent class name via AST walk.
+    // Walks up to the enclosing class, then extracts the superclass from its heritage node.
+    if (varName === 'super' || varName === 'base' || varName === 'parent') {
+        return findEnclosingParentClassName(callNode);
+    }
     // Determine the enclosing function scope for the call
     const scopeKey = findEnclosingScopeKey(callNode);
+    // Check position-indexed pattern overrides first (e.g., Kotlin when/is smart casts).
+    // These take priority over flat scopeEnv because they represent per-branch narrowing.
+    if (scopeKey && patternOverrides) {
+        const varOverrides = patternOverrides.get(scopeKey)?.get(varName);
+        if (varOverrides) {
+            const pos = callNode.startIndex;
+            for (const override of varOverrides) {
+                if (pos >= override.rangeStart && pos <= override.rangeEnd) {
+                    return fastStripNullable(override.typeName);
+                }
+            }
+        }
+    }
     // Try function-local scope first
     if (scopeKey) {
         const scopeEnv = env.get(scopeKey);
         if (scopeEnv) {
             const result = scopeEnv.get(varName);
             if (result)
-                return result;
+                return fastStripNullable(result);
         }
     }
     // Fall back to file-level scope
     const fileEnv = env.get(FILE_SCOPE);
-    return fileEnv?.get(varName);
+    const raw = fileEnv?.get(varName);
+    return raw ? fastStripNullable(raw) : undefined;
+};
+/**
+ * Walk up the AST from a node to find the enclosing class/module name.
+ * Used to resolve `self`/`this` receivers to their containing type.
+ */
+const findEnclosingClassName = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type)) {
+            const nameNode = current.childForFieldName('name')
+                ?? findTypeIdentifierChild(current);
+            if (nameNode)
+                return nameNode.text;
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/**
+ * Walk up the AST to find the enclosing class, then extract its parent class name
+ * from the heritage/superclass AST node. Used to resolve `super`/`base`/`parent`.
+ *
+ * Supported patterns per tree-sitter grammar:
+ * - Java/Ruby: `superclass` field → type_identifier/constant
+ * - Python: `superclasses` field → argument_list → first identifier
+ * - TypeScript/JS: unnamed `class_heritage` child → `extends_clause` → identifier
+ * - C#: unnamed `base_list` child → first identifier
+ * - PHP: unnamed `base_clause` child → name
+ * - Kotlin: unnamed `delegation_specifier` child → constructor_invocation → user_type → type_identifier
+ * - C++: unnamed `base_class_clause` child → type_identifier
+ * - Swift: unnamed `inheritance_specifier` child → user_type → type_identifier
+ */
+const findEnclosingParentClassName = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type)) {
+            return extractParentClassFromNode(current);
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/** Extract the parent/superclass name from a class declaration AST node. */
+const extractParentClassFromNode = (classNode) => {
+    // 1. Named fields: Java (superclass), Ruby (superclass), Python (superclasses)
+    const superclassNode = classNode.childForFieldName('superclass');
+    if (superclassNode) {
+        // Java: superclass > type_identifier or generic_type, Ruby: superclass > constant
+        const inner = superclassNode.childForFieldName('type')
+            ?? superclassNode.firstNamedChild
+            ?? superclassNode;
+        return extractSimpleTypeName(inner) ?? inner.text;
+    }
+    const superclassesNode = classNode.childForFieldName('superclasses');
+    if (superclassesNode) {
+        // Python: argument_list with identifiers or attribute nodes (e.g. models.Model)
+        const first = superclassesNode.firstNamedChild;
+        if (first)
+            return extractSimpleTypeName(first) ?? first.text;
+    }
+    // 2. Unnamed children: walk class node's children looking for heritage nodes
+    for (let i = 0; i < classNode.childCount; i++) {
+        const child = classNode.child(i);
+        if (!child)
+            continue;
+        switch (child.type) {
+            // TypeScript: class_heritage > extends_clause > type_identifier
+            // JavaScript: class_heritage > identifier (no extends_clause wrapper)
+            case 'class_heritage': {
+                for (let j = 0; j < child.childCount; j++) {
+                    const clause = child.child(j);
+                    if (clause?.type === 'extends_clause') {
+                        const typeNode = clause.firstNamedChild;
+                        if (typeNode)
+                            return extractSimpleTypeName(typeNode) ?? typeNode.text;
+                    }
+                    // JS: direct identifier child (no extends_clause wrapper)
+                    if (clause?.type === 'identifier' || clause?.type === 'type_identifier') {
+                        return clause.text;
+                    }
+                }
+                break;
+            }
+            // C#: base_list > identifier or generic_name > identifier
+            case 'base_list': {
+                const first = child.firstNamedChild;
+                if (first) {
+                    // generic_name wraps the identifier: BaseClass<T>
+                    if (first.type === 'generic_name') {
+                        const inner = first.childForFieldName('name') ?? first.firstNamedChild;
+                        if (inner)
+                            return inner.text;
+                    }
+                    return first.text;
+                }
+                break;
+            }
+            // PHP: base_clause > name
+            case 'base_clause': {
+                const name = child.firstNamedChild;
+                if (name)
+                    return name.text;
+                break;
+            }
+            // C++: base_class_clause > type_identifier (with optional access_specifier before it)
+            case 'base_class_clause': {
+                for (let j = 0; j < child.childCount; j++) {
+                    const inner = child.child(j);
+                    if (inner?.type === 'type_identifier')
+                        return inner.text;
+                }
+                break;
+            }
+            // Kotlin: delegation_specifier > constructor_invocation > user_type > type_identifier
+            case 'delegation_specifier': {
+                const delegate = child.firstNamedChild;
+                if (delegate?.type === 'constructor_invocation') {
+                    const userType = delegate.firstNamedChild;
+                    if (userType?.type === 'user_type') {
+                        const typeId = userType.firstNamedChild;
+                        if (typeId)
+                            return typeId.text;
+                    }
+                }
+                // Also handle plain user_type (interface conformance without parentheses)
+                if (delegate?.type === 'user_type') {
+                    const typeId = delegate.firstNamedChild;
+                    if (typeId)
+                        return typeId.text;
+                }
+                break;
+            }
+            // Swift: inheritance_specifier > user_type > type_identifier
+            case 'inheritance_specifier': {
+                const userType = child.childForFieldName('inherits_from') ?? child.firstNamedChild;
+                if (userType?.type === 'user_type') {
+                    const typeId = userType.firstNamedChild;
+                    if (typeId)
+                        return typeId.text;
+                }
+                break;
+            }
+        }
+    }
+    return undefined;
 };
 /** Find the enclosing function name for scope lookup. */
 const findEnclosingScopeKey = (node) => {
@@ -36,51 +242,318 @@ const findEnclosingScopeKey = (node) => {
     return undefined;
 };
 /**
- * Build a scoped TypeEnv from a tree-sitter AST for a given language.
- * Walks the tree tracking enclosing function scopes, so that variables
- * inside different functions don't collide.
+ * Create a lookup that checks both local AST class names AND the SymbolTable's
+ * global index. This allows extractInitializer functions to distinguish
+ * constructor calls from function calls (e.g. Kotlin `User()` vs `getUser()`)
+ * using cross-file type information when available.
+ *
+ * Only `.has()` is exposed — the SymbolTable doesn't support iteration.
+ * Results are memoized to avoid redundant lookupFuzzy scans across declarations.
  */
-export const buildTypeEnv = (tree, language) => {
-    const env = new Map();
-    walkForTypes(tree.rootNode, language, env, FILE_SCOPE);
-    return env;
-};
-const walkForTypes = (node, language, env, currentScope) => {
-    // Detect scope boundaries (function/method definitions)
-    let scope = currentScope;
-    if (FUNCTION_NODE_TYPES.has(node.type)) {
-        const { funcName } = extractFunctionName(node);
-        if (funcName)
-            scope = `${funcName}@${node.startIndex}`;
-    }
-    // Get or create the sub-map for this scope
-    if (!env.has(scope))
-        env.set(scope, new Map());
-    const scopeEnv = env.get(scope);
-    // Check if this node provides type information
-    extractTypeBinding(node, language, scopeEnv);
-    // Recurse into children
-    for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child)
-            walkForTypes(child, language, env, scope);
-    }
+const createClassNameLookup = (localNames, symbolTable) => {
+    if (!symbolTable)
+        return localNames;
+    const memo = new Map();
+    return {
+        has(name) {
+            if (localNames.has(name))
+                return true;
+            const cached = memo.get(name);
+            if (cached !== undefined)
+                return cached;
+            const result = symbolTable.lookupFuzzy(name).some(def => def.type === 'Class' || def.type === 'Enum' || def.type === 'Struct');
+            memo.set(name, result);
+            return result;
+        },
+    };
 };
 /**
- * Try to extract a (variableName → typeName) binding from a single AST node.
- * Delegates to per-language type configurations.
+ * Build a TypeEnvironment from a tree-sitter AST for a given language.
+ * Single-pass: collects class/struct names, type bindings, AND constructor
+ * bindings that couldn't be resolved locally — all in one AST walk.
+ *
+ * When a symbolTable is provided (call-processor path), class names from across
+ * the project are available for constructor inference in languages like Kotlin
+ * where constructors are syntactically identical to function calls.
  */
-const extractTypeBinding = (node, language, env) => {
-    // === PARAMETERS (most languages) ===
-    // This guard eliminates 90%+ of calls before any language dispatch.
-    if (TYPED_PARAMETER_TYPES.has(node.type)) {
-        const config = typeConfigs[language];
-        config.extractParameter(node, env);
-        return;
-    }
-    // === Per-language declaration extraction ===
+/**
+ * Node types whose subtrees can NEVER contain type-relevant descendants
+ * (declarations, parameters, for-loops, class definitions, pattern bindings).
+ * Conservative leaf-only set — verified safe across all 12 supported language grammars.
+ * IMPORTANT: Do NOT add expression containers (arguments, binary_expression, etc.) —
+ * they can contain arrow functions with typed parameters.
+ */
+const SKIP_SUBTREE_TYPES = new Set([
+    // Plain string literals (NOT template_string — it contains interpolated expressions
+    // that can hold arrow functions with typed parameters, e.g. `${(x: T) => x}`)
+    'string', 'string_literal',
+    'string_content', 'string_fragment', 'heredoc_body',
+    // Comments
+    'comment', 'line_comment', 'block_comment',
+    // Numeric/boolean/null literals
+    'number', 'integer_literal', 'float_literal',
+    'true', 'false', 'null',
+    // Regex
+    'regex', 'regex_pattern',
+]);
+export const buildTypeEnv = (tree, language, symbolTable) => {
+    const env = new Map();
+    const patternOverrides = new Map();
+    const localClassNames = new Set();
+    const classNames = createClassNameLookup(localClassNames, symbolTable);
     const config = typeConfigs[language];
-    if (config.declarationNodeTypes.has(node.type)) {
-        config.extractDeclaration(node, env);
+    const bindings = [];
+    // Pre-compute combined set of node types that need extractTypeBinding.
+    // Single Set.has() replaces 3 separate checks per node in walk().
+    const interestingNodeTypes = new Set();
+    TYPED_PARAMETER_TYPES.forEach(t => interestingNodeTypes.add(t));
+    config.declarationNodeTypes.forEach(t => interestingNodeTypes.add(t));
+    config.forLoopNodeTypes?.forEach(t => interestingNodeTypes.add(t));
+    const pendingAssignments = [];
+    // Maps `scope\0varName` → the type annotation AST node from the original declaration.
+    // Allows pattern extractors to navigate back to the declaration's generic type arguments
+    // (e.g., to extract T from Result<T, E> for `if let Ok(x) = res`).
+    // NOTE: This is a SUPERSET of scopeEnv — entries exist even when extractSimpleTypeName
+    // returns undefined for container types (User[], []User, List[User]). This is intentional:
+    // for-loop Strategy 1 needs the raw AST type node for exactly those container types.
+    const declarationTypeNodes = new Map();
+    /**
+     * Try to extract a (variableName → typeName) binding from a single AST node.
+     *
+     * Resolution tiers (first match wins):
+     * - Tier 0: explicit type annotations via extractDeclaration / extractForLoopBinding
+     * - Tier 1: constructor-call inference via extractInitializer (fallback)
+     *
+     * Side effect: populates declarationTypeNodes for variables that have an explicit
+     * type annotation field on the declaration node. This allows pattern extractors to
+     * retrieve generic type arguments from the original declaration (e.g., extracting T
+     * from Result<T, E> for `if let Ok(x) = res`).
+     */
+    const extractTypeBinding = (node, scopeEnv, scope) => {
+        // This guard eliminates 90%+ of calls before any language dispatch.
+        if (TYPED_PARAMETER_TYPES.has(node.type)) {
+            // Capture the raw type annotation BEFORE extractParameter.
+            // Most languages use 'name' field; Rust uses 'pattern'; TS uses 'pattern' for some param types.
+            // Kotlin `parameter` nodes use positional children instead of named fields,
+            // so we fall back to scanning children by type when childForFieldName returns null.
+            let typeNode = node.childForFieldName('type');
+            if (typeNode) {
+                const nameNode = node.childForFieldName('name')
+                    ?? node.childForFieldName('pattern');
+                if (nameNode) {
+                    const varName = extractVarName(nameNode);
+                    if (varName && !declarationTypeNodes.has(`${scope}\0${varName}`)) {
+                        declarationTypeNodes.set(`${scope}\0${varName}`, typeNode);
+                    }
+                }
+            }
+            else {
+                // Fallback: positional children (Kotlin `parameter` → simple_identifier + user_type)
+                let fallbackName = null;
+                let fallbackType = null;
+                for (let i = 0; i < node.namedChildCount; i++) {
+                    const child = node.namedChild(i);
+                    if (!child)
+                        continue;
+                    if (!fallbackName && (child.type === 'simple_identifier' || child.type === 'identifier')) {
+                        fallbackName = child;
+                    }
+                    if (!fallbackType && (child.type === 'user_type' || child.type === 'type_identifier'
+                        || child.type === 'generic_type' || child.type === 'parameterized_type')) {
+                        fallbackType = child;
+                    }
+                }
+                if (fallbackName && fallbackType) {
+                    const varName = extractVarName(fallbackName);
+                    if (varName && !declarationTypeNodes.has(`${scope}\0${varName}`)) {
+                        declarationTypeNodes.set(`${scope}\0${varName}`, fallbackType);
+                    }
+                }
+            }
+            config.extractParameter(node, scopeEnv);
+            return;
+        }
+        // For-each loop variable bindings (Java/C#/Kotlin): explicit element types in the AST.
+        // Checked before declarationNodeTypes — loop variables are not declarations.
+        if (config.forLoopNodeTypes?.has(node.type)) {
+            config.extractForLoopBinding?.(node, scopeEnv, declarationTypeNodes, scope);
+            return;
+        }
+        if (config.declarationNodeTypes.has(node.type)) {
+            // Capture the raw type annotation AST node BEFORE extractDeclaration.
+            // This decouples type node capture from scopeEnv success — container types
+            // (User[], []User, List[User]) that fail extractSimpleTypeName still get
+            // their AST type node recorded for Strategy 1 for-loop resolution.
+            // Try direct extraction first (works for Go var_spec, Python assignment, Rust let_declaration).
+            // Try direct type field first, then unwrap wrapper nodes (C# field_declaration,
+            // local_declaration_statement wrap their type inside a variable_declaration child).
+            let typeNode = node.childForFieldName('type');
+            if (!typeNode) {
+                // C# field_declaration / local_declaration_statement wrap type inside variable_declaration.
+                // Use manual loop instead of namedChildren.find() to avoid array allocation on hot path.
+                let wrapped = node.childForFieldName('declaration');
+                if (!wrapped) {
+                    for (let i = 0; i < node.namedChildCount; i++) {
+                        const c = node.namedChild(i);
+                        if (c?.type === 'variable_declaration') {
+                            wrapped = c;
+                            break;
+                        }
+                    }
+                }
+                if (wrapped)
+                    typeNode = wrapped.childForFieldName('type');
+            }
+            if (typeNode) {
+                const nameNode = node.childForFieldName('name')
+                    ?? node.childForFieldName('left')
+                    ?? node.childForFieldName('pattern');
+                if (nameNode) {
+                    const varName = extractVarName(nameNode);
+                    if (varName && !declarationTypeNodes.has(`${scope}\0${varName}`)) {
+                        declarationTypeNodes.set(`${scope}\0${varName}`, typeNode);
+                    }
+                }
+            }
+            // Run the language-specific declaration extractor (may or may not add to scopeEnv).
+            const keysBefore = typeNode ? new Set(scopeEnv.keys()) : undefined;
+            config.extractDeclaration(node, scopeEnv);
+            // Fallback: for multi-declarator languages (TS, C#, Java) where the type field
+            // is on variable_declarator children, capture via keysBefore/keysAfter diff.
+            if (typeNode && keysBefore) {
+                for (const varName of scopeEnv.keys()) {
+                    if (!keysBefore.has(varName) && !declarationTypeNodes.has(`${scope}\0${varName}`)) {
+                        declarationTypeNodes.set(`${scope}\0${varName}`, typeNode);
+                    }
+                }
+            }
+            // Tier 1: constructor-call inference as fallback.
+            // Always called when available — each language's extractInitializer
+            // internally skips declarators that already have explicit annotations,
+            // so this handles mixed cases like `const a: A = x, b = new B()`.
+            if (config.extractInitializer) {
+                config.extractInitializer(node, scopeEnv, classNames);
+            }
+        }
+    };
+    const walk = (node, currentScope) => {
+        // Fast skip: subtrees that can never contain type-relevant nodes (leaf-like literals).
+        if (SKIP_SUBTREE_TYPES.has(node.type))
+            return;
+        // Collect class/struct names as we encounter them (used by extractInitializer
+        // to distinguish constructor calls from function calls, e.g. C++ `User()` vs `getUser()`)
+        // Currently only C++ uses this locally; other languages rely on the SymbolTable path.
+        if (CLASS_CONTAINER_TYPES.has(node.type)) {
+            // Most languages use 'name' field; Kotlin uses a type_identifier child instead
+            const nameNode = node.childForFieldName('name')
+                ?? findTypeIdentifierChild(node);
+            if (nameNode)
+                localClassNames.add(nameNode.text);
+        }
+        // Detect scope boundaries (function/method definitions)
+        let scope = currentScope;
+        if (FUNCTION_NODE_TYPES.has(node.type)) {
+            const { funcName } = extractFunctionName(node);
+            if (funcName)
+                scope = `${funcName}@${node.startIndex}`;
+        }
+        // Only create scope map and call extractTypeBinding for interesting node types.
+        // Single Set.has() replaces 3 separate checks inside extractTypeBinding.
+        if (interestingNodeTypes.has(node.type)) {
+            if (!env.has(scope))
+                env.set(scope, new Map());
+            const scopeEnv = env.get(scope);
+            extractTypeBinding(node, scopeEnv, scope);
+        }
+        // Pattern binding extraction: handles constructs that introduce NEW typed variables
+        // via pattern matching (e.g. `if let Some(x) = opt`, `x instanceof T t`).
+        // Runs after Tier 0/1 so scopeEnv already contains the source variable's type.
+        // Conservative: extractor returns undefined when source type is unknown.
+        if (config.extractPatternBinding && (!config.patternBindingNodeTypes || config.patternBindingNodeTypes.has(node.type))) {
+            // Ensure scopeEnv exists for pattern binding reads/writes
+            if (!env.has(scope))
+                env.set(scope, new Map());
+            const scopeEnv = env.get(scope);
+            const patternBinding = config.extractPatternBinding(node, scopeEnv, declarationTypeNodes, scope);
+            if (patternBinding) {
+                if (config.allowPatternBindingOverwrite) {
+                    // Position-indexed: store per-branch binding for smart-cast narrowing.
+                    // Each when arm / switch case gets its own type for the variable,
+                    // preventing cross-arm contamination (e.g., Kotlin when/is).
+                    const branchNode = findPatternBranchScope(node);
+                    if (branchNode) {
+                        if (!patternOverrides.has(scope))
+                            patternOverrides.set(scope, new Map());
+                        const varMap = patternOverrides.get(scope);
+                        if (!varMap.has(patternBinding.varName))
+                            varMap.set(patternBinding.varName, []);
+                        varMap.get(patternBinding.varName).push({
+                            rangeStart: branchNode.startIndex,
+                            rangeEnd: branchNode.endIndex,
+                            typeName: patternBinding.typeName,
+                        });
+                    }
+                    // Also store in flat scopeEnv as fallback (last arm wins — same as before
+                    // for code that doesn't use position-indexed lookup).
+                    scopeEnv.set(patternBinding.varName, patternBinding.typeName);
+                }
+                else if (!scopeEnv.has(patternBinding.varName)) {
+                    // First-writer-wins for languages without smart-cast overwrite (Java instanceof, etc.)
+                    scopeEnv.set(patternBinding.varName, patternBinding.typeName);
+                }
+            }
+        }
+        // Tier 2: collect plain-identifier RHS assignments for post-walk propagation.
+        // Delegates to per-language extractPendingAssignment — AST shapes differ widely
+        // (JS uses variable_declarator/name/value, Rust uses let_declaration/pattern/value,
+        // Python uses assignment/left/right, Go uses short_var_declaration/expression_list).
+        if (config.extractPendingAssignment && config.declarationNodeTypes.has(node.type)) {
+            // scopeEnv is guaranteed to exist here because declarationNodeTypes is a subset
+            // of interestingNodeTypes, so extractTypeBinding already created the scope map above.
+            const scopeEnv = env.get(scope);
+            if (scopeEnv) {
+                const pending = config.extractPendingAssignment(node, scopeEnv);
+                if (pending) {
+                    pendingAssignments.push({ scope, ...pending });
+                }
+            }
+        }
+        // Scan for constructor bindings that couldn't be resolved locally.
+        // Only collect if TypeEnv didn't already resolve this binding.
+        if (config.scanConstructorBinding) {
+            const result = config.scanConstructorBinding(node);
+            if (result) {
+                const scopeEnv = env.get(scope);
+                if (!scopeEnv?.has(result.varName)) {
+                    bindings.push({ scope, ...result });
+                }
+            }
+        }
+        // Recurse into children
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                walk(child, scope);
+        }
+    };
+    walk(tree.rootNode, FILE_SCOPE);
+    // Tier 2: single-pass assignment chain propagation in source order.
+    // Resolves `const b = a` where `a` has a known type from Tier 0/1.
+    // Multi-hop chains resolve when forward-declared (a→b→c in source order);
+    // reverse-order assignments are depth-1 only. No fixpoint iteration —
+    // this covers 95%+ of real-world patterns.
+    for (const { scope, lhs, rhs } of pendingAssignments) {
+        const scopeEnv = env.get(scope);
+        if (!scopeEnv || scopeEnv.has(lhs))
+            continue;
+        const rhsType = scopeEnv.get(rhs) ?? env.get(FILE_SCOPE)?.get(rhs);
+        if (rhsType) {
+            scopeEnv.set(lhs, rhsType);
+        }
     }
+    return {
+        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides),
+        constructorBindings: bindings,
+        env,
+    };
 };