umple-lsp-server 0.2.1 → 0.2.4

package/out/symbolIndex.js

@@ -12,50 +12,11 @@ const path = require("path");
 // web-tree-sitter types and module
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const TreeSitter = require("web-tree-sitter");
-/**
- * Keywords after which the next token is always a new name (definition).
- * Completions are suppressed when the cursor immediately follows one of these.
- */
-const DEFINITION_KEYWORDS = new Set([
-    "class",
-    "interface",
-    "trait",
-    "enum",
-    "mixset",
-    "req",
-    "associationClass",
-    "statemachine",
-    "namespace",
-    "generate",
-    // State machine modifiers — next token is SM name (or another modifier)
-    "queued",
-    "pooled",
-    // Emit methods — next token is the method name
-    "emit",
-]);
-/** Structural tokens that should NOT appear in completions. */
-const STRUCTURAL_TOKENS = new Set([
-    "{",
-    "}",
-    "(",
-    ")",
-    "[",
-    "]",
-    ";",
-    ",",
-    ".",
-    "<",
-    ">",
-    "=",
-    "/",
-    "[]",
-    "*",
-    "||",
-]);
-function isOperatorToken(name) {
-    // Matches association/transition arrows: --, ->, <-, <@>-, -<@>, >->, <-<
-    return /^[<>-]/.test(name) && name.length > 1;
-}
+const treeUtils_1 = require("./treeUtils");
+const tokenAnalysis_1 = require("./tokenAnalysis");
+const completionAnalysis_1 = require("./completionAnalysis");
+const referenceSearch_1 = require("./referenceSearch");
+const importGraph_1 = require("./importGraph");
 class SymbolIndex {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     parser = null;
@@ -69,6 +30,8 @@ class SymbolIndex {
     isAByFile = new Map();
     // Global isA graph: className → parent names (merged from all files)
     isAGraph = new Map();
+    // Import graph: forward/reverse edge management
+    importGraph = new importGraph_1.ImportGraph();
     initialized = false;
     /**
      * Initialize the tree-sitter parser with the Umple grammar.
@@ -116,6 +79,41 @@ class SymbolIndex {
     isReady() {
         return this.initialized && this.parser !== null;
     }
+    /**
+     * Check if a file has been fully indexed (has symbols + tree).
+     */
+    isFileIndexed(filePath) {
+        return this.files.has(filePath);
+    }
+    /**
+     * Remove import graph edges for a file (e.g., when it's deleted from disk).
+     */
+    removeImportEdges(filePath) {
+        this.importGraph.removeEdges(filePath);
+    }
+    /**
+     * Update import graph edges for a file from its use statements,
+     * WITHOUT full symbol indexing. Used by the async workspace use-graph scanner.
+     * Skips files that are already fully indexed (their edges are fresh from didOpen/didChange).
+     */
+    updateUseGraphEdges(filePath, useStatements) {
+        // Don't overwrite edges for already-indexed files
+        if (this.files.has(filePath))
+            return;
+        const fileDir = path.dirname(filePath);
+        const resolvedImports = new Set();
+        for (const usePath of useStatements) {
+            if (!usePath.endsWith(".ump"))
+                continue;
+            const resolved = path.isAbsolute(usePath)
+                ? path.normalize(usePath)
+                : path.normalize(path.resolve(fileDir, usePath));
+            if (fs.existsSync(resolved)) {
+                resolvedImports.add(resolved);
+            }
+        }
+        this.importGraph.setEdges(filePath, resolvedImports);
+    }
     /**
      * Index a file or update its index if content changed.
      * @param filePath Absolute path to the file
@@ -134,14 +132,32 @@ class SymbolIndex {
             // Content unchanged, skip re-indexing
             return false;
         }
-        // Remove old symbols for this file from the name index
+        // Parse the file
+        const tree = this.parser.parse(fileContent);
+        // Remove old symbols for this file from the container index
         if (existing) {
             this.removeFileSymbols(filePath);
         }
-        // Parse the file
-        const tree = this.parser.parse(fileContent);
-        // Extract symbols from the AST
-        const symbols = this.extractSymbols(filePath, tree.rootNode);
+        const newSymbols = this.extractSymbols(filePath, tree.rootNode);
+        // Kind-sensitive error preservation: when the tree has errors,
+        // live-update recovery-safe kinds (whose identity doesn't depend
+        // on AST nesting) but preserve recovery-fragile kinds (state,
+        // statemachine) from the last clean snapshot.
+        let symbols;
+        if (tree.rootNode.hasError) {
+            const LIVE_KINDS = new Set([
+                "class", "interface", "trait", "enum",
+                "mixset", "attribute", "const",
+            ]);
+            const liveSymbols = newSymbols.filter((s) => LIVE_KINDS.has(s.kind));
+            const preservedSymbols = existing
+                ? existing.symbols.filter((s) => !LIVE_KINDS.has(s.kind))
+                : [];
+            symbols = [...liveSymbols, ...preservedSymbols];
+        }
+        else {
+            symbols = newSymbols;
+        }
         // Extract isA relationships
         const isAMap = this.extractIsARelationships(tree.rootNode);
         this.isAByFile.set(filePath, isAMap);
@@ -160,11 +176,12 @@ class SymbolIndex {
                 this.symbolsByContainer.set(symbol.container, containerSyms);
             }
         }
+        // Update forward/reverse import maps
+        this.updateImportMaps(filePath, fileContent);
         return true;
     }
     /**
-     * Update a file with new content.
-     * For web-tree-sitter, we do a full reparse but the index diffing is still efficient.
+     * Update a file with new content from the live editor.
      */
     updateFile(filePath, content) {
         return this.indexFile(filePath, content);
@@ -211,6 +228,22 @@ class SymbolIndex {
         }
         return result;
     }
+    /**
+     * Get all symbols defined in a specific file (for document outline).
+     */
+    getFileSymbols(filePath) {
+        return this.files.get(filePath)?.symbols ?? [];
+    }
+    /**
+     * Get the parsed tree for a file (for formatting, etc.).
+     */
+    getTree(filePath) {
+        return this.files.get(filePath)?.tree ?? null;
+    }
+    /** Get the direct isA parents for a class name. */
+    getIsAParents(className) {
+        return this.isAGraph.get(className) ?? [];
+    }
     collectFromContainerChain(container, kindSet, name, visited, result) {
         if (visited.has(container))
             return;
@@ -256,8 +289,8 @@ class SymbolIndex {
         const usePaths = [];
         const visit = (node) => {
             if (node.type === "use_statement") {
-                const pathNode = node.childForFieldName("path");
-                if (pathNode) {
+                const pathNodes = node.childrenForFieldName("path");
+                for (const pathNode of pathNodes) {
                     usePaths.push(pathNode.text);
                 }
             }
@@ -298,8 +331,8 @@ class SymbolIndex {
         const useStatements = [];
         const visit = (node) => {
             if (node.type === "use_statement") {
-                const pathNode = node.childForFieldName("path");
-                if (pathNode) {
+                const pathNodes = node.childrenForFieldName("path");
+                for (const pathNode of pathNodes) {
                     useStatements.push({
                         path: pathNode.text,
                         line: node.startPosition.row,
@@ -318,17 +351,8 @@ class SymbolIndex {
         return useStatements;
     }
     /**
-     * Get completion information at a position using LookaheadIterator + scope query.
-     *
-     * Operates on the ORIGINAL parse tree (no dummy insertion). Uses:
-     * 1. Previous leaf node's nextParseState → LookaheadIterator for keywords
-     * 2. completions.scm query for symbol kind detection
-     * 3. Simple tree checks for comments, definition names
-     *
-     * @param content The document text (original)
-     * @param line 0-indexed cursor line
-     * @param column 0-indexed cursor column
-     * @returns CompletionInfo with keywords, operators, and symbol kinds
+     * Get completion information at a position.
+     * Delegates to the pure analyzeCompletion() function after tree acquisition.
      */
     getCompletionInfo(content, line, column) {
         const empty = {
@@ -339,96 +363,22 @@ class SymbolIndex {
             isComment: false,
             prefix: "",
         };
-        if (!this.initialized || !this.parser || !this.language) {
+        if (!this.initialized || !this.parser || !this.language || !this.completionsQuery) {
             return empty;
         }
-        // Parse original text (no dummy insertion)
         const tree = this.parser.parse(content);
         if (!tree)
             return empty;
-        // --- Comment check ---
-        // Use column - 1 to land inside the token when cursor is at its end boundary
-        // (tree-sitter uses half-open intervals [start, end))
-        const nodeAtCursor = tree.rootNode.descendantForPosition({
-            row: line,
-            column: Math.max(0, column - 1),
-        });
-        if (nodeAtCursor && this.isInsideComment(nodeAtCursor)) {
-            return { ...empty, isComment: true };
-        }
-        // --- Extract prefix from the token at cursor ---
-        let prefix = "";
-        if (column > 0 &&
-            nodeAtCursor &&
-            (nodeAtCursor.type === "identifier" || nodeAtCursor.type === "use_path")) {
-            const nodeStartCol = nodeAtCursor.startPosition.row === line
-                ? nodeAtCursor.startPosition.column
-                : 0;
-            prefix = nodeAtCursor.text.substring(0, column - nodeStartCol);
-        }
-        // --- Definition name check ---
-        const lastToken = this.lastTokenBeforeCursor(content, line, column);
-        if ((lastToken && DEFINITION_KEYWORDS.has(lastToken)) ||
-            this.isAtAttributeNamePosition(tree, content, line, column)) {
-            return { ...empty, isDefinitionName: true };
-        }
-        // --- LookaheadIterator for keywords ---
-        const prevLeaf = this.findPreviousLeaf(tree, content, line, column);
-        // When no previous token exists (file start / after only comments),
-        // use the node at cursor's parseState instead of state 0.
-        // State 0 is the initial LR state which is overly broad.
-        const stateId = prevLeaf
-            ? prevLeaf.nextParseState
-            : (nodeAtCursor?.parseState ?? 0);
-        const keywords = [];
-        const operators = [];
-        const iter = this.language.lookaheadIterator(stateId);
-        if (iter) {
-            try {
-                for (const symbolName of iter) {
-                    const typeId = iter.currentTypeId;
-                    // Skip named nodes (identifier, type_name, etc.)
-                    if (this.language.nodeTypeIsNamed(typeId))
-                        continue;
-                    // Skip structural tokens
-                    if (STRUCTURAL_TOKENS.has(symbolName))
-                        continue;
-                    if (isOperatorToken(symbolName)) {
-                        operators.push(symbolName);
-                    }
-                    else if (/^[a-zA-Z]/.test(symbolName)) {
-                        keywords.push(symbolName);
-                    }
-                }
-            }
-            finally {
-                iter.delete(); // MUST free WASM memory
-            }
-        }
-        // --- Scope query for symbol kinds ---
-        const symbolKinds = this.resolveCompletionScope(tree, line, column);
-        // --- Enclosing scope for scoped lookups ---
-        const { enclosingClass, enclosingStateMachine } = this.resolveEnclosingScope(tree, line, column);
-        return {
-            keywords,
-            operators,
-            symbolKinds,
-            isDefinitionName: false,
-            isComment: false,
-            prefix,
-            enclosingClass,
-            enclosingStateMachine,
-        };
+        return (0, completionAnalysis_1.analyzeCompletion)(tree, this.language, this.completionsQuery, content, line, column);
     }
     /**
      * Get the token (identifier) at a position using tree-sitter, along with
-     * an optional SymbolKind filter based on the surrounding context.
+     * context information for symbol resolution.
      *
-     * Uses the references.scm query to determine which symbol kinds are valid
-     * for the cursor's context. See queries/references.scm for supported patterns.
+     * Delegates to the pure analyzeToken() function after tree acquisition.
      */
     getTokenAtPosition(filePath, content, line, column) {
-        if (!this.initialized || !this.parser) {
+        if (!this.initialized || !this.parser || !this.referencesQuery) {
             return null;
         }
         const fileIndex = this.files.get(filePath);
@@ -440,14 +390,39 @@ class SymbolIndex {
         else {
             tree = this.parser.parse(content);
         }
+        return (0, tokenAnalysis_1.analyzeToken)(tree, this.referencesQuery, line, column);
+    }
+    /**
+     * Get the exact range of the token node at a position.
+     * Used by prepareRename to return the precise rename range.
+     * Accepts the same node types as getTokenAtPosition(): identifier,
+     * use_path, and filter_pattern.
+     */
+    getNodeRangeAtPosition(filePath, content, line, column) {
+        if (!this.initialized || !this.parser)
+            return null;
+        const fileIndex = this.files.get(filePath);
+        let tree;
+        if (fileIndex?.tree &&
+            fileIndex.contentHash === this.hashContent(content)) {
+            tree = fileIndex.tree;
+        }
+        else {
+            tree = this.parser.parse(content);
+        }
         const node = tree.rootNode.descendantForPosition({ row: line, column });
-        if (!node || (node.type !== "identifier" && node.type !== "use_path")) {
+        if (!node ||
+            (node.type !== "identifier" &&
+                node.type !== "use_path" &&
+                node.type !== "filter_pattern")) {
             return null;
         }
-        const word = node.text;
-        const kinds = this.resolveDefinitionKinds(tree, node);
-        const { enclosingClass, enclosingStateMachine } = this.resolveEnclosingScope(tree, line, column);
-        return { word, kinds, enclosingClass, enclosingStateMachine };
+        return {
+            startLine: node.startPosition.row,
+            startColumn: node.startPosition.column,
+            endLine: node.endPosition.row,
+            endColumn: node.endPosition.column,
+        };
     }
     /**
      * Use the references.scm query to determine which symbol kinds an
@@ -457,263 +432,83 @@ class SymbolIndex {
      * encoding the valid symbol kinds directly. This replaces the old parent-chain
      * walking approach with a declarative .scm file.
      */
-    resolveDefinitionKinds(tree, node) {
-        if (!this.referencesQuery)
-            return null;
-        // Run query with position filtering to find captures at this node
-        const captures = this.referencesQuery.captures(tree.rootNode, {
-            startPosition: node.startPosition,
-            endPosition: node.endPosition,
-        });
-        // Find the capture whose node best matches our target.
-        // When multiple patterns capture the same node (e.g. isA type matched
-        // by both type_name and isa_declaration), pick the most specific:
-        //   1. Smallest node size (fewest bytes)
-        //   2. Fewest kinds in the capture name (fewer = more specific)
-        let bestCapture = null;
-        let bestSize = Infinity;
-        let bestKindCount = Infinity;
-        for (const capture of captures) {
-            if (capture.node.startIndex <= node.startIndex &&
-                capture.node.endIndex >= node.endIndex) {
-                const size = capture.node.endIndex - capture.node.startIndex;
-                const kindCount = capture.name.split("_").length;
-                if (size < bestSize ||
-                    (size === bestSize && kindCount < bestKindCount)) {
-                    bestSize = size;
-                    bestKindCount = kindCount;
-                    bestCapture = capture;
-                }
-            }
-        }
-        if (!bestCapture)
-            return null;
-        // Parse capture name: "reference.class_interface_trait" → ["class", "interface", "trait"]
-        const prefix = "reference.";
-        if (!bestCapture.name.startsWith(prefix))
-            return null;
-        const kindStr = bestCapture.name.substring(prefix.length);
-        return kindStr.split("_");
-    }
-    // =====================
-    // Private methods
-    // =====================
     /**
-     * Find the previous non-extra leaf node before the cursor position.
-     * Skips the current partial word being typed and any whitespace.
+     * Get the names of direct child states of a given state path within a state machine.
+     * Uses pre-computed statePath on each SymbolEntry for O(n) lookup without AST walking.
      *
-     * @param tree    The (original, un-modified) parse tree
-     * @param content The document text
-     * @param line    0-indexed cursor line
-     * @param column  0-indexed cursor column
-     * @returns The previous leaf node, or null if cursor is at file start
-     */
-    findPreviousLeaf(tree, content, line, column) {
-        // Convert (line, column) to absolute offset
-        const lines = content.split("\n");
-        let offset = 0;
-        for (let i = 0; i < line && i < lines.length; i++) {
-            offset += lines[i].length + 1; // +1 for newline
-        }
-        offset += Math.min(column, lines[line]?.length ?? 0);
-        // Skip the current partial identifier backwards
-        let pos = offset;
-        while (pos > 0 && /[a-zA-Z_0-9]/.test(content[pos - 1])) {
-            pos--;
-        }
-        // Skip whitespace backwards
-        while (pos > 0 && /\s/.test(content[pos - 1])) {
-            pos--;
-        }
-        if (pos === 0)
-            return null;
-        // Find the node at (pos - 1) — the last character before the gap
-        let node = tree.rootNode.descendantForIndex(pos - 1, pos - 1);
-        if (!node)
-            return null;
-        // Skip extra nodes (comments) by walking to previous siblings
-        while (node && node.isExtra) {
-            const prev = node.previousSibling;
-            if (prev) {
-                node = prev;
-                while (node.childCount > 0) {
-                    node = node.lastChild;
-                }
-            }
-            else if (node.parent) {
-                node = node.parent;
-            }
-            else {
-                return null;
-            }
-        }
-        // Walk to leaf
-        while (node && node.childCount > 0) {
-            node = node.lastChild;
-        }
-        return node;
-    }
-    /**
-     * Run completions.scm to find the innermost scope at the cursor position.
-     * Returns symbol kinds to offer, "suppress", "use_path", or null (keywords only).
-     */
-    resolveCompletionScope(tree, line, column) {
-        if (!this.completionsQuery)
-            return null;
-        // Don't pass position filtering to the query — tree-sitter uses
-        // half-open intervals [start, end), so a point query at a node's
-        // exact end boundary misses it (e.g., `use Per|` at use_statement's
-        // end). The manual containment check below uses inclusive boundaries
-        // and handles this correctly.
-        const captures = this.completionsQuery.captures(tree.rootNode);
-        // Find the innermost (smallest) scope that contains the cursor
-        let best = null;
-        for (const capture of captures) {
-            const node = capture.node;
-            const startOk = node.startPosition.row < line ||
-                (node.startPosition.row === line &&
-                    node.startPosition.column <= column);
-            const endOk = node.endPosition.row > line ||
-                (node.endPosition.row === line && node.endPosition.column >= column);
-            if (startOk && endOk) {
-                const size = node.endIndex - node.startIndex;
-                if (!best || size < best.size) {
-                    best = { name: capture.name, size };
-                }
-            }
-        }
-        if (!best)
-            return null;
-        const prefix = "scope.";
-        if (!best.name.startsWith(prefix))
-            return null;
-        const kindStr = best.name.substring(prefix.length);
-        if (kindStr === "suppress")
-            return "suppress";
-        if (kindStr === "use_path")
-            return "use_path";
-        if (kindStr === "own_attribute")
-            return "own_attribute";
-        if (kindStr === "none")
-            return null;
-        return kindStr.split("_");
-    }
-    /**
-     * Check if a node is inside a comment (line_comment or block_comment).
-     */
-    isInsideComment(node) {
-        let current = node;
-        while (current) {
-            if (current.type === "line_comment" || current.type === "block_comment") {
-                return true;
-            }
-            current = current.parent;
-        }
-        return false;
-    }
-    /**
-     * Resolve enclosing class and root state machine names at a position.
-     * For state machines, keeps walking to find the outermost (root) SM.
+     * @param parentPath Path segments to the parent state (e.g., ["EEE", "Open"])
+     * @param smContainer Qualified SM container (e.g., "ClassName.smName")
+     * @returns Names of direct child states of the resolved parent
      */
-    resolveEnclosingScope(tree, line, column) {
-        let node = tree.rootNode.descendantForPosition({
-            row: line,
-            column,
+    getChildStateNames(parentPath, smContainer, reachableFiles) {
+        if (parentPath.length === 0)
+            return [];
+        const effectivePath = (0, treeUtils_1.stripSmPrefix)(parentPath, smContainer);
+        if (effectivePath.length === 0)
+            return [];
+        const allStates = this.getSymbols({
+            container: smContainer,
+            kind: "state",
         });
-        let enclosingClass;
-        let enclosingStateMachine;
-        while (node) {
-            // For state machines: keep overwriting to find the ROOT (outermost) SM
-            if (node.type === "state_machine") {
-                enclosingStateMachine =
-                    node.childForFieldName("name")?.text ?? enclosingStateMachine;
-            }
-            if (node.type === "statemachine_definition") {
-                enclosingStateMachine =
-                    node.childForFieldName("name")?.text ?? enclosingStateMachine;
-            }
-            // For class: stop at first (innermost is what we want)
-            if (!enclosingClass &&
-                [
-                    "class_definition",
-                    "trait_definition",
-                    "interface_definition",
-                    "association_class_definition",
-                ].includes(node.type)) {
-                enclosingClass = node.childForFieldName("name")?.text;
-            }
-            node = node.parent;
-        }
-        return { enclosingClass, enclosingStateMachine };
-    }
-    /**
-     * Check if the cursor is at an attribute name position (after a type name).
-     * E.g., "Integer |" — the previous leaf is inside a type_name that is the
-     * "type" field of an attribute_declaration, const_declaration, method, or param.
-     */
-    isAtAttributeNamePosition(tree, content, line, column) {
-        const prevLeaf = this.findPreviousLeaf(tree, content, line, column);
-        if (!prevLeaf)
-            return false;
-        // Walk up to find if prevLeaf is inside a type_name
-        let node = prevLeaf;
-        while (node) {
-            if (node.type === "type_name") {
-                const parent = node.parent;
-                if (parent) {
-                    for (let i = 0; i < parent.childCount; i++) {
-                        if (parent.child(i)?.id === node.id) {
-                            const fieldName = parent.fieldNameForChild(i);
-                            if (fieldName === "type" || fieldName === "return_type") {
-                                return true;
-                            }
-                        }
-                    }
+        const names = new Set();
+        for (const s of allStates) {
+            if (reachableFiles && !reachableFiles.has(path.normalize(s.file)))
+                continue;
+            if (!s.statePath || s.statePath.length < effectivePath.length + 1)
+                continue;
+            // Suffix match: check if effectivePath matches the segments ending
+            // just before the child name (e.g., ["Closed"] matches tail of ["EEE","Closed","Inner"])
+            const suffixStart = s.statePath.length - effectivePath.length - 1;
+            let match = true;
+            for (let i = 0; i < effectivePath.length; i++) {
+                if (s.statePath[suffixStart + i] !== effectivePath[i]) {
+                    match = false;
+                    break;
                 }
-                break;
             }
-            node = node.parent;
+            if (match)
+                names.add(s.name);
         }
-        return false;
+        return [...names];
     }
     /**
-     * Scan backwards from the cursor position to find the token before the
-     * word currently being typed. Skips the current partial identifier first,
-     * then whitespace, then extracts the previous token.
+     * Resolve a state within a dotted path context, returning the matching SymbolEntry.
+     * Uses pre-computed statePath for exact path matching without AST walking.
      *
-     * Examples (| = cursor):
-     *   "class |"      → "class"
-     *   "class Fo|"    → "class"
-     *   "class\n  Fo|" → "class"
+     * @param precedingPath Path segments before the target (e.g., ["EEE", "Open"])
+     * @param targetName The target state name (e.g., "Inner")
+     * @param smContainer Qualified SM container (e.g., "ClassName.smName")
+     * @returns The SymbolEntry for the target state, or undefined if not found
      */
-    lastTokenBeforeCursor(content, line, column) {
-        const lines = content.split("\n");
-        // Convert (line, column) to absolute offset
-        let offset = 0;
-        for (let i = 0; i < line && i < lines.length; i++) {
-            offset += lines[i].length + 1; // +1 for newline
-        }
-        offset += Math.min(column, lines[line]?.length ?? 0);
-        // Skip the current partial identifier (the word being typed)
-        let pos = offset;
-        while (pos > 0 && /[a-zA-Z_0-9]/.test(content[pos - 1])) {
-            pos--;
-        }
-        // Skip whitespace
-        while (pos > 0 && /\s/.test(content[pos - 1])) {
-            pos--;
-        }
-        if (pos === 0)
-            return null;
-        // Collect the previous token
-        let start = pos;
-        while (start > 0 && /[a-zA-Z_]/.test(content[start - 1])) {
-            start--;
-        }
-        if (start === pos)
-            return null; // Hit punctuation, not a word
-        return content.substring(start, pos);
+    resolveStateInPath(precedingPath, targetName, smContainer, reachableFiles) {
+        if (precedingPath.length === 0)
+            return undefined;
+        const effectivePath = (0, treeUtils_1.stripSmPrefix)(precedingPath, smContainer);
+        const targetPath = [...effectivePath, targetName];
+        let candidates = this.getSymbols({
+            container: smContainer,
+            kind: "state",
+            name: targetName,
+        });
+        if (reachableFiles) {
+            candidates = candidates.filter((s) => reachableFiles.has(path.normalize(s.file)));
+        }
+        // Suffix match: targetPath may be a partial path (e.g., ["Closed","Inner"])
+        // that matches the tail of a full statePath (e.g., ["EEE","Closed","Inner"])
+        return candidates.find((s) => {
+            if (!s.statePath || s.statePath.length < targetPath.length)
+                return false;
+            const offset = s.statePath.length - targetPath.length;
+            for (let i = 0; i < targetPath.length; i++) {
+                if (s.statePath[offset + i] !== targetPath[i])
+                    return false;
+            }
+            return true;
+        });
     }
+    // =====================
+    // Private methods
+    // =====================
     readFileSafe(filePath) {
         try {
             return fs.readFileSync(filePath, "utf-8");
@@ -838,6 +633,7 @@ class SymbolIndex {
      */
     resolveStateMachineContainer(node) {
         let rootSmName;
+        let className;
         let current = node.parent;
         while (current) {
             if (current.type === "state_machine") {
@@ -846,10 +642,36 @@ class SymbolIndex {
             if (current.type === "statemachine_definition") {
                 rootSmName = current.childForFieldName("name")?.text ?? rootSmName;
             }
+            if (!className &&
+                [
+                    "class_definition",
+                    "trait_definition",
+                    "interface_definition",
+                    "association_class_definition",
+                ].includes(current.type)) {
+                className = current.childForFieldName("name")?.text;
+            }
             current = current.parent;
         }
-        return rootSmName;
+        if (!rootSmName)
+            return undefined;
+        return className ? `${className}.${rootSmName}` : rootSmName;
     }
+    /** For enum values: walk up to find the enclosing enum_definition name. */
+    resolveEnumContainer(node) {
+        let current = node.parent;
+        while (current) {
+            if (current.type === "enum_definition") {
+                return current.childForFieldName("name")?.text;
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
+    /**
+     * Build the nesting path for a state by walking up parent state nodes.
+     * E.g., for Inner inside Open inside EEE: ["EEE", "Open", "Inner"]
+     */
     /**
      * Extract symbol definitions from the AST using the definitions.scm query.
      * Falls back to an empty list if the query isn't loaded.
@@ -870,15 +692,22 @@ class SymbolIndex {
                 container = this.resolveStateMachineContainer(node);
             }
             else if (kind === "attribute" ||
+                kind === "const" ||
                 kind === "method" ||
-                kind === "template") {
+                kind === "template" ||
+                kind === "tracecase") {
                 container = this.resolveClassContainer(node);
             }
+            else if (kind === "enum_value") {
+                // Enum values belong to their enclosing enum
+                container = this.resolveEnumContainer(node);
+            }
             else {
                 // Top-level symbols (class, interface, trait, enum, etc.) are self-containers
                 container = node.text;
             }
-            symbols.push({
+            const defNode = node.parent;
+            const entry = {
                 name: node.text,
                 kind,
                 file: filePath,
@@ -887,10 +716,174 @@ class SymbolIndex {
                 endLine: node.endPosition.row,
                 endColumn: node.endPosition.column,
                 container,
-            });
+                defLine: defNode?.startPosition.row,
+                defColumn: defNode?.startPosition.column,
+                defEndLine: defNode?.endPosition.row,
+                defEndColumn: defNode?.endPosition.column,
+            };
+            if (kind === "state") {
+                entry.statePath = (0, treeUtils_1.resolveStatePath)(node);
+            }
+            symbols.push(entry);
         }
         return symbols;
     }
+    // ── Workspace indexing & import graph ──────────────────────────────────
+    /**
+     * Scan workspace roots for all .ump files, follow use chains to external
+     * files, and index everything. Content-hash skips unchanged files.
+     *
+     * @param workspaceRoots Workspace root directories
+     * @param getOpenDocContent Returns in-memory editor content if the file is open, undefined otherwise
+     */
+    indexWorkspace(workspaceRoots, getOpenDocContent) {
+        if (!this.initialized || !this.parser)
+            return;
+        // 1. Discover all .ump files under workspace roots
+        const discoveredFiles = new Set();
+        for (const root of workspaceRoots) {
+            this.globUmpFiles(root, discoveredFiles);
+        }
+        // 2. Index each discovered file (open-doc content takes precedence)
+        for (const filePath of discoveredFiles) {
+            const openContent = getOpenDocContent(filePath);
+            if (openContent !== undefined) {
+                this.indexFile(filePath, openContent);
+            }
+            else {
+                this.indexFile(filePath);
+            }
+        }
+        // 3. Follow use chains to index external files (outside workspace roots)
+        //    Only treat an external file as live if it's open in the editor or exists on disk.
+        //    This prevents stale forward-import edges from re-adding deleted files.
+        const externalFiles = new Set();
+        for (const filePath of discoveredFiles) {
+            const imports = this.importGraph.getForward(filePath);
+            if (imports) {
+                for (const imp of imports) {
+                    if (!discoveredFiles.has(imp) &&
+                        !externalFiles.has(imp) &&
+                        (getOpenDocContent(imp) !== undefined || fs.existsSync(imp))) {
+                        externalFiles.add(imp);
+                    }
+                }
+            }
+        }
+        // Index external files and follow their chains too (transitive)
+        const queue = [...externalFiles];
+        while (queue.length > 0) {
+            const filePath = queue.pop();
+            const openContent = getOpenDocContent(filePath);
+            if (openContent !== undefined) {
+                this.indexFile(filePath, openContent);
+            }
+            else {
+                this.indexFile(filePath);
+            }
+            const imports = this.importGraph.getForward(filePath);
+            if (imports) {
+                for (const imp of imports) {
+                    if (!discoveredFiles.has(imp) &&
+                        !externalFiles.has(imp) &&
+                        (getOpenDocContent(imp) !== undefined || fs.existsSync(imp))) {
+                        externalFiles.add(imp);
+                        queue.push(imp);
+                    }
+                }
+            }
+        }
+        // 4. Remove stale indexed files.
+        //    A file is removed if it's not in the discovered/external set AND not open in the editor.
+        //    Note: fs.existsSync is intentionally NOT checked here — a file that still exists on disk
+        //    but is no longer reachable (e.g., use statement removed) should be dropped from the index.
+        const allKnownFiles = new Set([...discoveredFiles, ...externalFiles]);
+        for (const filePath of this.files.keys()) {
+            if (!allKnownFiles.has(filePath) &&
+                getOpenDocContent(filePath) === undefined) {
+                this.removeFile(filePath);
+            }
+        }
+    }
+    /**
+     * Get all files whose use chain can reach any of the given declaration files.
+     * Transitive reverse closure.
+     */
+    getReverseImporters(declarationFiles) {
+        return this.importGraph.getReverseImporters(declarationFiles);
+    }
+    /**
+     * Find all references to a symbol across the given files.
+     * Delegates to the extracted searchReferences() function.
+     */
+    findReferences(declarations, filesToSearch, includeDeclaration) {
+        if (!this.referencesQuery || declarations.length === 0)
+            return [];
+        // Build filePath→tree map for the files to search
+        const fileTreeMap = new Map();
+        for (const fp of filesToSearch) {
+            const tree = this.files.get(fp)?.tree;
+            if (tree)
+                fileTreeMap.set(fp, tree);
+        }
+        return (0, referenceSearch_1.searchReferences)(declarations, includeDeclaration, this.referencesQuery, fileTreeMap, this.isAGraph);
+    }
+    /**
+     * Update forward/reverse import maps for a file.
+     */
+    updateImportMaps(filePath, content) {
+        // Compute resolved imports from use statements
+        const usePaths = this.extractUseStatements(filePath, content);
+        const fileDir = path.dirname(filePath);
+        const newImports = new Set();
+        for (const usePath of usePaths) {
+            if (!usePath.endsWith(".ump"))
+                continue;
+            const resolved = path.isAbsolute(usePath)
+                ? path.normalize(usePath)
+                : path.normalize(path.resolve(fileDir, usePath));
+            if (fs.existsSync(resolved)) {
+                newImports.add(resolved);
+            }
+        }
+        // Delegate edge management to ImportGraph
+        this.importGraph.setEdges(filePath, newImports);
+    }
+    /**
+     * Fully remove a file from the index (symbols, imports, isA).
+     */
+    removeFile(filePath) {
+        this.removeFileSymbols(filePath);
+        this.files.delete(filePath);
+        this.importGraph.removeEdges(filePath);
+        this.isAByFile.delete(filePath);
+        this.rebuildIsAGraph();
+    }
+    /**
+     * Recursively find all .ump files under a directory.
+     */
+    globUmpFiles(dir, result) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // permission denied, etc.
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip common non-source directories
+                if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "out") {
+                    continue;
+                }
+                this.globUmpFiles(fullPath, result);
+            }
+            else if (entry.name.endsWith(".ump")) {
+                result.add(path.normalize(fullPath));
+            }
+        }
+    }
 }
 exports.SymbolIndex = SymbolIndex;
 // Singleton instance