umple-lsp-server 0.1.0 → 0.2.0

package/out/symbolIndex.js

@@ -8,16 +8,67 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.symbolIndex = exports.SymbolIndex = void 0;
 const fs = require("fs");
+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");
-const DUMMY_IDENTIFIER = "__CURSOR__";
+/**
+ * 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;
+}
 class SymbolIndex {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     parser = null;
     language = null;
+    referencesQuery = null;
+    definitionsQuery = null;
+    completionsQuery = null;
     files = new Map();
-    symbolsByName = new Map();
+    symbolsByContainer = new Map();
+    // Per-file isA relationships (for cleanup when a file is re-indexed)
+    isAByFile = new Map();
+    // Global isA graph: className → parent names (merged from all files)
+    isAGraph = new Map();
     initialized = false;
     /**
      * Initialize the tree-sitter parser with the Umple grammar.
@@ -32,6 +83,23 @@ class SymbolIndex {
             // Load the WASM language
             this.language = await TreeSitter.Language.load(wasmPath);
             this.parser.setLanguage(this.language);
+            // Load .scm queries (co-located with WASM after build)
+            const queryDir = path.dirname(wasmPath);
+            const referencesScmPath = path.join(queryDir, "references.scm");
+            if (fs.existsSync(referencesScmPath)) {
+                const src = fs.readFileSync(referencesScmPath, "utf-8");
+                this.referencesQuery = new TreeSitter.Query(this.language, src);
+            }
+            const definitionsScmPath = path.join(queryDir, "definitions.scm");
+            if (fs.existsSync(definitionsScmPath)) {
+                const src = fs.readFileSync(definitionsScmPath, "utf-8");
+                this.definitionsQuery = new TreeSitter.Query(this.language, src);
+            }
+            const completionsScmPath = path.join(queryDir, "completions.scm");
+            if (fs.existsSync(completionsScmPath)) {
+                const src = fs.readFileSync(completionsScmPath, "utf-8");
+                this.completionsQuery = new TreeSitter.Query(this.language, src);
+            }
             this.initialized = true;
             return true;
         }
@@ -74,17 +142,23 @@ class SymbolIndex {
         const tree = this.parser.parse(fileContent);
         // Extract symbols from the AST
         const symbols = this.extractSymbols(filePath, tree.rootNode);
+        // Extract isA relationships
+        const isAMap = this.extractIsARelationships(tree.rootNode);
+        this.isAByFile.set(filePath, isAMap);
+        this.rebuildIsAGraph();
         // Store the file index
         this.files.set(filePath, {
             symbols,
             tree,
             contentHash: hash,
         });
-        // Add symbols to the name index
+        // Add symbols to the container index
         for (const symbol of symbols) {
-            const existing = this.symbolsByName.get(symbol.name) ?? [];
-            existing.push(symbol);
-            this.symbolsByName.set(symbol.name, existing);
+            if (symbol.container) {
+                const containerSyms = this.symbolsByContainer.get(symbol.container) ?? [];
+                containerSyms.push(symbol);
+                this.symbolsByContainer.set(symbol.container, containerSyms);
+            }
         }
         return true;
     }
@@ -96,115 +170,65 @@ class SymbolIndex {
         return this.indexFile(filePath, content);
     }
     /**
-     * Find definition of a symbol by name.
-     * @param name Symbol name to look up
-     * @param kind Optional kind filter
-     * @returns Array of matching symbol entries
-     */
-    findDefinition(name, kind) {
-        const symbols = this.symbolsByName.get(name) ?? [];
-        if (kind) {
-            return symbols.filter((s) => s.kind === kind);
-        }
-        return symbols;
-    }
-    /**
-     * Find definition with context (for resolving attributes/states within a class/statemachine).
-     * @param name Symbol name
-     * @param parentName Parent symbol name (class or statemachine name)
-     */
-    findDefinitionInContext(name, parentName) {
-        const symbols = this.symbolsByName.get(name) ?? [];
-        return symbols.filter((s) => s.parent === parentName);
-    }
-    /**
-     * Get all symbols in a file.
-     */
-    getFileSymbols(filePath) {
-        return this.files.get(filePath)?.symbols ?? [];
-    }
-    /**
-     * Get all indexed files.
-     */
-    getIndexedFiles() {
-        return Array.from(this.files.keys());
-    }
-    /**
-     * Get all symbol names.
-     */
-    getAllSymbolNames() {
-        return Array.from(this.symbolsByName.keys());
-    }
-    /**
-     * Remove a file from the index.
-     */
-    removeFile(filePath) {
-        this.removeFileSymbols(filePath);
-        this.files.delete(filePath);
-    }
-    /**
-     * Clear the entire index.
-     */
-    clear() {
-        this.files.clear();
-        this.symbolsByName.clear();
-    }
-    /**
-     * Get index statistics.
-     */
-    getStats() {
-        let totalSymbols = 0;
-        for (const fileIndex of this.files.values()) {
-            totalSymbols += fileIndex.symbols.length;
-        }
-        return {
-            files: this.files.size,
-            symbols: totalSymbols,
-            uniqueNames: this.symbolsByName.size,
-        };
-    }
-    /**
-     * Check if a position is inside a comment.
-     * @param filePath Path to the file
-     * @param content File content (if available, otherwise reads from disk)
-     * @param line 0-indexed line number
-     * @param column 0-indexed column number
+     * Unified symbol lookup. All old getters are replaced by this method.
+     *
+     * @param opts.container  Scope to this container (class name or SM name)
+     * @param opts.kind       Filter by kind(s)
+     * @param opts.name       Filter by symbol name
+     * @param opts.inherited  Walk isA chain when container is specified
      */
-    isPositionInComment(filePath, content, line, column) {
-        if (!this.initialized || !this.parser) {
-            return false;
-        }
-        // Get or create tree
-        let tree = null;
-        const fileIndex = this.files.get(filePath);
-        if (fileIndex?.tree) {
-            tree = fileIndex.tree;
-        }
-        else if (content) {
-            tree = this.parser.parse(content);
-        }
-        else {
-            const fileContent = this.readFileSafe(filePath);
-            if (fileContent) {
-                tree = this.parser.parse(fileContent);
+    getSymbols(opts) {
+        const kindSet = opts.kind
+            ? new Set(Array.isArray(opts.kind) ? opts.kind : [opts.kind])
+            : null;
+        if (opts.container) {
+            const result = [];
+            if (opts.inherited) {
+                this.collectFromContainerChain(opts.container, kindSet, opts.name, new Set(), result);
             }
+            else {
+                const syms = this.symbolsByContainer.get(opts.container) ?? [];
+                for (const s of syms) {
+                    if (kindSet && !kindSet.has(s.kind))
+                        continue;
+                    if (opts.name && s.name !== opts.name)
+                        continue;
+                    result.push(s);
+                }
+            }
+            return result;
         }
-        if (!tree) {
-            return false;
-        }
-        const node = tree.rootNode.descendantForPosition({ row: line, column });
-        if (!node) {
-            return false;
+        // No container: iterate all containers
+        const result = [];
+        for (const syms of this.symbolsByContainer.values()) {
+            for (const s of syms) {
+                if (kindSet && !kindSet.has(s.kind))
+                    continue;
+                if (opts.name && s.name !== opts.name)
+                    continue;
+                result.push(s);
+            }
         }
-        // Check if the node or any ancestor is a comment
-        let current = node;
-        while (current) {
-            if (current.type === "line_comment" || current.type === "block_comment") {
-                return true;
+        return result;
+    }
+    collectFromContainerChain(container, kindSet, name, visited, result) {
+        if (visited.has(container))
+            return;
+        visited.add(container);
+        const syms = this.symbolsByContainer.get(container) ?? [];
+        for (const s of syms) {
+            if (kindSet && !kindSet.has(s.kind))
+                continue;
+            if (name && s.name !== name)
+                continue;
+            result.push(s);
+        }
+        const parents = this.isAGraph.get(container);
+        if (parents) {
+            for (const parent of parents) {
+                this.collectFromContainerChain(parent, kindSet, name, visited, result);
             }
-            current = current.parent;
         }
-        return false;
     }
     /**
      * Extract use statement paths from a file using tree-sitter.
@@ -294,18 +318,119 @@ class SymbolIndex {
         return useStatements;
     }
     /**
-     * Get the use path at a specific position, if the cursor is on a use statement.
-     * @param filePath Path to the file
-     * @param content File content
-     * @param line 0-indexed line number
-     * @param column 0-indexed column number
-     * @returns The use path (without quotes) or null if not on a use statement
+     * 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
+     */
+    getCompletionInfo(content, line, column) {
+        const empty = {
+            keywords: [],
+            operators: [],
+            symbolKinds: null,
+            isDefinitionName: false,
+            isComment: false,
+            prefix: "",
+        };
+        if (!this.initialized || !this.parser || !this.language) {
+            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,
+        };
+    }
+    /**
+     * Get the token (identifier) at a position using tree-sitter, along with
+     * an optional SymbolKind filter based on the surrounding context.
+     *
+     * Uses the references.scm query to determine which symbol kinds are valid
+     * for the cursor's context. See queries/references.scm for supported patterns.
      */
-    getUsePathAtPosition(filePath, content, line, column) {
+    getTokenAtPosition(filePath, content, line, column) {
         if (!this.initialized || !this.parser) {
             return null;
         }
-        // Use cached tree if available
         const fileIndex = this.files.get(filePath);
         let tree;
         if (fileIndex?.tree &&
@@ -316,212 +441,278 @@ class SymbolIndex {
             tree = this.parser.parse(content);
         }
         const node = tree.rootNode.descendantForPosition({ row: line, column });
-        if (!node) {
+        if (!node || (node.type !== "identifier" && node.type !== "use_path")) {
             return null;
         }
-        // Walk up to find if we're inside a use_statement
-        let current = node;
-        while (current) {
-            if (current.type === "use_statement") {
-                const pathNode = current.childForFieldName("path");
-                if (pathNode) {
-                    return pathNode.text;
+        const word = node.text;
+        const kinds = this.resolveDefinitionKinds(tree, node);
+        const { enclosingClass, enclosingStateMachine } = this.resolveEnclosingScope(tree, line, column);
+        return { word, kinds, enclosingClass, enclosingStateMachine };
+    }
+    /**
+     * Use the references.scm query to determine which symbol kinds an
+     * identifier can reference based on its position in the AST.
+     *
+     * The query captures identifiers with names like @reference.class_interface_trait,
+     * 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;
                 }
-                return null;
             }
-            current = current.parent;
         }
-        return null;
+        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
+    // =====================
     /**
-     * Get the completion context at a specific position using the dummy identifier trick.
+     * Find the previous non-extra leaf node before the cursor position.
+     * Skips the current partial word being typed and any whitespace.
      *
-     * Inserts a dummy identifier (__CURSOR__) at the cursor position, parses the
-     * modified text, then walks up from the dummy node to determine context.
-     * This produces reliable results because the dummy forces the parser to place
-     * it in a grammatically valid position (e.g. "isA __CURSOR__" parses as an
-     * isa_declaration with type __CURSOR__).
-     *
-     * @param filePath Path to the file
-     * @param content File content (original, without dummy)
-     * @param line 0-indexed line number
-     * @param column 0-indexed column number (raw cursor position, NOT column-1)
-     * @returns The completion context type
+     * @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
      */
-    getCompletionContext(filePath, content, line, column) {
-        if (!this.initialized || !this.parser) {
-            return "unknown";
-        }
-        // Insert dummy identifier at cursor position
+    findPreviousLeaf(tree, content, line, column) {
+        // Convert (line, column) to absolute offset
         const lines = content.split("\n");
-        if (line < 0 || line >= lines.length) {
-            return "unknown";
-        }
-        const lineText = lines[line];
-        lines[line] =
-            lineText.substring(0, column) +
-                DUMMY_IDENTIFIER +
-                lineText.substring(column);
-        const modifiedText = lines.join("\n");
-        // Parse modified text (throwaway — do NOT update index)
-        const tree = this.parser.parse(modifiedText);
-        // Find the dummy node — it starts at (line, column) in the modified text
-        const dummyNode = tree.rootNode.descendantForPosition({
-            row: line,
-            column,
-        });
-        if (!dummyNode) {
-            return "unknown";
+        let offset = 0;
+        for (let i = 0; i < line && i < lines.length; i++) {
+            offset += lines[i].length + 1; // +1 for newline
         }
-        // Walk up from the dummy node to determine context
-        let current = dummyNode;
-        while (current) {
-            switch (current.type) {
-                // Comments: suppress all completions
-                case "line_comment":
-                case "block_comment":
-                    return "comment";
-                // Specific keyword contexts (checked before structural)
-                case "use_statement":
-                    return "use_path";
-                case "isa_declaration":
-                    return "isa_type";
-                case "transition": {
-                    const targetNode = current.childForFieldName("target");
-                    if (targetNode && targetNode.text.includes(DUMMY_IDENTIFIER)) {
-                        return "transition_target";
-                    }
-                    // Dummy is in event position — fall through to state context
-                    return "state";
-                }
-                case "depend_statement":
-                    return "depend_package";
-                case "association_inline": {
-                    const rightType = current.childForFieldName("right_type");
-                    if (rightType && rightType.text.includes(DUMMY_IDENTIFIER)) {
-                        return "association_type";
-                    }
-                    // Dummy is in role or other position — fall through
-                    break;
-                }
-                case "association_member": {
-                    const leftType = current.childForFieldName("left_type");
-                    const rightType = current.childForFieldName("right_type");
-                    if ((leftType && leftType.text.includes(DUMMY_IDENTIFIER)) ||
-                        (rightType && rightType.text.includes(DUMMY_IDENTIFIER))) {
-                        return "association_type";
-                    }
-                    return "association";
+        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;
                 }
-                // Brace-delimited: always reliable
-                case "state":
-                    return "state";
-                case "state_machine":
-                    return "state_machine";
-                case "association_definition":
-                    return "association";
-                case "enum_definition":
-                    return "enum";
-                case "class_definition":
-                case "trait_definition":
-                case "interface_definition":
-                    return "class_body";
-                case "source_file":
-                    return "top";
-                case "code_content":
-                case "code_block":
-                    return "method";
             }
-            current = current.parent;
+            else if (node.parent) {
+                node = node.parent;
+            }
+            else {
+                return null;
+            }
+        }
+        // Walk to leaf
+        while (node && node.childCount > 0) {
+            node = node.lastChild;
         }
-        return "unknown";
+        return node;
     }
     /**
-     * Get all symbols of a specific kind from the index.
-     * @param kind The kind of symbols to retrieve
-     * @returns Array of symbol entries of that kind
+     * Run completions.scm to find the innermost scope at the cursor position.
+     * Returns symbol kinds to offer, "suppress", "use_path", or null (keywords only).
      */
-    getSymbolsByKind(kind) {
-        const result = [];
-        for (const symbols of this.symbolsByName.values()) {
-            for (const symbol of symbols) {
-                if (symbol.kind === kind) {
-                    result.push(symbol);
+    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 };
                 }
             }
         }
-        return result;
+        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("_");
     }
     /**
-     * Get all symbols (useful for type completions).
+     * Check if a node is inside a comment (line_comment or block_comment).
      */
-    getAllSymbols() {
-        const result = [];
-        for (const symbols of this.symbolsByName.values()) {
-            result.push(...symbols);
+    isInsideComment(node) {
+        let current = node;
+        while (current) {
+            if (current.type === "line_comment" || current.type === "block_comment") {
+                return true;
+            }
+            current = current.parent;
         }
-        return result;
+        return false;
     }
-    // =====================
-    // Private methods
-    // =====================
     /**
-     * Debug helper: print a tree-sitter AST as an S-expression with positions.
-     * Output matches the format used by `tree-sitter parse` and Neovim InspectTree.
+     * Resolve enclosing class and root state machine names at a position.
+     * For state machines, keeps walking to find the outermost (root) SM.
      */
-    debugPrintTree(content) {
-        if (!this.initialized || !this.parser) {
-            return null;
-        }
-        const tree = this.parser.parse(content);
-        const lines = [];
-        const visit = (node, depth) => {
-            const indent = "  ".repeat(depth);
-            const field = node.parent ? this.getFieldName(node.parent, node) : null;
-            const prefix = field ? `${field}: ` : "";
-            const pos = `[${node.startPosition.row}, ${node.startPosition.column}] - [${node.endPosition.row}, ${node.endPosition.column}]`;
-            if (node.childCount === 0) {
-                lines.push(`${indent}${prefix}(${node.type} ${pos}) "${node.text}"`);
+    resolveEnclosingScope(tree, line, column) {
+        let node = tree.rootNode.descendantForPosition({
+            row: line,
+            column,
+        });
+        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;
             }
-            else {
-                lines.push(`${indent}${prefix}(${node.type} ${pos}`);
-                for (let i = 0; i < node.childCount; i++) {
-                    const child = node.child(i);
-                    if (child)
-                        visit(child, depth + 1);
+            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;
+                            }
+                        }
+                    }
                 }
-                lines.push(`${indent})`);
+                break;
             }
-        };
-        visit(tree.rootNode, 0);
-        return lines.join("\n");
+            node = node.parent;
+        }
+        return false;
     }
     /**
-     * Get the field name for a child node within its parent.
+     * 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.
+     *
+     * Examples (| = cursor):
+     *   "class |"      → "class"
+     *   "class Fo|"    → "class"
+     *   "class\n  Fo|" → "class"
      */
-    getFieldName(parent, child) {
-        // Check common field names used in the Umple grammar
-        const fieldNames = [
-            "name",
-            "path",
-            "type",
-            "return_type",
-            "left_role",
-            "right_role",
-            "right_type",
-            "left_type",
-            "event",
-            "target",
-            "package",
-            "language",
-        ];
-        for (const name of fieldNames) {
-            const fieldNode = parent.childForFieldName(name);
-            if (fieldNode && fieldNode.id === child.id) {
-                return name;
-            }
-        }
-        return null;
+    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);
     }
     readFileSafe(filePath) {
         try {
@@ -536,14 +727,16 @@ class SymbolIndex {
         if (!fileIndex)
             return;
         for (const symbol of fileIndex.symbols) {
-            const symbols = this.symbolsByName.get(symbol.name);
-            if (symbols) {
-                const filtered = symbols.filter((s) => s.file !== filePath);
-                if (filtered.length === 0) {
-                    this.symbolsByName.delete(symbol.name);
-                }
-                else {
-                    this.symbolsByName.set(symbol.name, filtered);
+            if (symbol.container) {
+                const containerSyms = this.symbolsByContainer.get(symbol.container);
+                if (containerSyms) {
+                    const filtered = containerSyms.filter((s) => s.file !== filePath);
+                    if (filtered.length === 0) {
+                        this.symbolsByContainer.delete(symbol.container);
+                    }
+                    else {
+                        this.symbolsByContainer.set(symbol.container, filtered);
+                    }
                 }
             }
         }
@@ -559,143 +752,143 @@ class SymbolIndex {
         }
         return hash.toString(16);
     }
-    extractSymbols(filePath, rootNode) {
-        const symbols = [];
-        const visit = (node, parent) => {
-            switch (node.type) {
-                case "class_definition":
-                case "interface_definition":
-                case "trait_definition":
-                case "enum_definition":
-                case "external_definition": {
-                    const nameNode = node.childForFieldName("name");
-                    if (nameNode) {
-                        let kind = node.type.replace("_definition", "");
-                        if (node.type === "external_definition") {
-                            kind = "class";
-                        }
-                        symbols.push({
-                            name: nameNode.text,
-                            kind,
-                            file: filePath,
-                            line: nameNode.startPosition.row,
-                            column: nameNode.startPosition.column,
-                            endLine: nameNode.endPosition.row,
-                            endColumn: nameNode.endPosition.column,
-                        });
-                        // Visit children with this class as parent
-                        for (let i = 0; i < node.childCount; i++) {
-                            const child = node.child(i);
-                            if (child)
-                                visit(child, nameNode.text);
-                        }
-                    }
-                    break;
-                }
-                case "attribute_declaration": {
-                    const nameNode = node.childForFieldName("name");
-                    if (nameNode && parent) {
-                        symbols.push({
-                            name: nameNode.text,
-                            kind: "attribute",
-                            file: filePath,
-                            line: nameNode.startPosition.row,
-                            column: nameNode.startPosition.column,
-                            endLine: nameNode.endPosition.row,
-                            endColumn: nameNode.endPosition.column,
-                            parent,
-                        });
-                    }
-                    break;
-                }
-                case "state_machine": {
-                    const nameNode = node.childForFieldName("name");
-                    if (nameNode && parent) {
-                        symbols.push({
-                            name: nameNode.text,
-                            kind: "statemachine",
-                            file: filePath,
-                            line: nameNode.startPosition.row,
-                            column: nameNode.startPosition.column,
-                            endLine: nameNode.endPosition.row,
-                            endColumn: nameNode.endPosition.column,
-                            parent,
-                        });
-                        // Visit states with this statemachine as parent
-                        for (let i = 0; i < node.childCount; i++) {
-                            const child = node.child(i);
-                            if (child && child.type === "state") {
-                                visit(child, nameNode.text);
-                            }
-                        }
-                    }
-                    break;
+    /**
+     * Extract isA relationships from the AST.
+     * Returns a map of className → parent names.
+     */
+    extractIsARelationships(rootNode) {
+        const isAMap = new Map();
+        const visit = (node) => {
+            if (node.type === "isa_declaration") {
+                // Find enclosing class name
+                let parent = node.parent;
+                while (parent &&
+                    ![
+                        "class_definition",
+                        "trait_definition",
+                        "interface_definition",
+                        "association_class_definition",
+                    ].includes(parent.type)) {
+                    parent = parent.parent;
                 }
-                case "state": {
-                    const nameNode = node.childForFieldName("name");
-                    if (nameNode && parent) {
-                        symbols.push({
-                            name: nameNode.text,
-                            kind: "state",
-                            file: filePath,
-                            line: nameNode.startPosition.row,
-                            column: nameNode.startPosition.column,
-                            endLine: nameNode.endPosition.row,
-                            endColumn: nameNode.endPosition.column,
-                            parent,
-                        });
-                        // Visit nested states
-                        for (let i = 0; i < node.childCount; i++) {
-                            const child = node.child(i);
-                            if (child && child.type === "state") {
-                                visit(child, nameNode.text);
+                const className = parent?.childForFieldName("name")?.text;
+                if (!className)
+                    return;
+                // Extract parent names from type_list → type_name → qualified_name
+                for (let i = 0; i < node.childCount; i++) {
+                    const child = node.child(i);
+                    if (child?.type === "type_list") {
+                        for (let j = 0; j < child.childCount; j++) {
+                            const tn = child.child(j);
+                            if (tn?.type === "type_name") {
+                                for (let k = 0; k < tn.childCount; k++) {
+                                    const qn = tn.child(k);
+                                    if (qn?.type === "qualified_name") {
+                                        const parents = isAMap.get(className) ?? [];
+                                        parents.push(qn.text);
+                                        isAMap.set(className, parents);
+                                    }
+                                }
                             }
                         }
                     }
-                    break;
-                }
-                case "method_declaration":
-                case "method_signature": {
-                    const nameNode = node.childForFieldName("name");
-                    if (nameNode && parent) {
-                        symbols.push({
-                            name: nameNode.text,
-                            kind: "method",
-                            file: filePath,
-                            line: nameNode.startPosition.row,
-                            column: nameNode.startPosition.column,
-                            endLine: nameNode.endPosition.row,
-                            endColumn: nameNode.endPosition.column,
-                            parent,
-                        });
-                    }
-                    break;
                 }
-                case "association_definition": {
-                    const nameNode = node.childForFieldName("name");
-                    if (nameNode) {
-                        symbols.push({
-                            name: nameNode.text,
-                            kind: "association",
-                            file: filePath,
-                            line: nameNode.startPosition.row,
-                            column: nameNode.startPosition.column,
-                            endLine: nameNode.endPosition.row,
-                            endColumn: nameNode.endPosition.column,
-                        });
-                    }
-                    break;
+            }
+            else {
+                for (let i = 0; i < node.childCount; i++) {
+                    const child = node.child(i);
+                    if (child)
+                        visit(child);
                 }
-                default:
-                    // Visit all children for other node types
-                    for (let i = 0; i < node.childCount; i++) {
-                        const child = node.child(i);
-                        if (child)
-                            visit(child, parent);
-                    }
             }
         };
         visit(rootNode);
+        return isAMap;
+    }
+    /** Rebuild the global isA graph from all per-file isA maps. */
+    rebuildIsAGraph() {
+        this.isAGraph.clear();
+        for (const fileIsA of this.isAByFile.values()) {
+            for (const [className, parents] of fileIsA) {
+                const existing = this.isAGraph.get(className) ?? [];
+                existing.push(...parents);
+                this.isAGraph.set(className, existing);
+            }
+        }
+    }
+    /** For attributes/methods: walk up to find the enclosing class name. */
+    resolveClassContainer(node) {
+        let current = node.parent;
+        while (current) {
+            if ([
+                "class_definition",
+                "trait_definition",
+                "interface_definition",
+                "association_class_definition",
+            ].includes(current.type)) {
+                return current.childForFieldName("name")?.text;
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
+    /**
+     * For states/statemachines: walk up to find the ROOT (outermost) state machine name.
+     * All states share the same container so nested states can target any state at any level.
+     */
+    resolveStateMachineContainer(node) {
+        let rootSmName;
+        let current = node.parent;
+        while (current) {
+            if (current.type === "state_machine") {
+                rootSmName = current.childForFieldName("name")?.text ?? rootSmName;
+            }
+            if (current.type === "statemachine_definition") {
+                rootSmName = current.childForFieldName("name")?.text ?? rootSmName;
+            }
+            current = current.parent;
+        }
+        return rootSmName;
+    }
+    /**
+     * Extract symbol definitions from the AST using the definitions.scm query.
+     * Falls back to an empty list if the query isn't loaded.
+     */
+    extractSymbols(filePath, rootNode) {
+        if (!this.definitionsQuery)
+            return [];
+        const captures = this.definitionsQuery.captures(rootNode);
+        const symbols = [];
+        for (const capture of captures) {
+            const prefix = "definition.";
+            if (!capture.name.startsWith(prefix))
+                continue;
+            const kind = capture.name.substring(prefix.length);
+            const node = capture.node;
+            let container;
+            if (kind === "state" || kind === "statemachine") {
+                container = this.resolveStateMachineContainer(node);
+            }
+            else if (kind === "attribute" ||
+                kind === "method" ||
+                kind === "template") {
+                container = this.resolveClassContainer(node);
+            }
+            else {
+                // Top-level symbols (class, interface, trait, enum, etc.) are self-containers
+                container = node.text;
+            }
+            symbols.push({
+                name: node.text,
+                kind,
+                file: filePath,
+                line: node.startPosition.row,
+                column: node.startPosition.column,
+                endLine: node.endPosition.row,
+                endColumn: node.endPosition.column,
+                container,
+            });
+        }
         return symbols;
     }
 }