umple-lsp-server 0.4.2 → 1.0.0

package/out/server.js

@@ -8,6 +8,7 @@ const zlib = require("zlib");
 const url_1 = require("url");
 const node_1 = require("vscode-languageserver/node");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const codeActions_1 = require("./codeActions");
 const symbolIndex_1 = require("./symbolIndex");
 const tokenTypes_1 = require("./tokenTypes");
 const resolver_1 = require("./resolver");
@@ -16,7 +17,12 @@ const hoverBuilder_1 = require("./hoverBuilder");
 const renameValidation_1 = require("./renameValidation");
 const traitSmEventResolver_1 = require("./traitSmEventResolver");
 const documentSymbolBuilder_1 = require("./documentSymbolBuilder");
+const workspaceSymbolBuilder_1 = require("./workspaceSymbolBuilder");
 const formatter_1 = require("./formatter");
+const completionTriggers_1 = require("./completionTriggers");
+const diagnosticSources_1 = require("./diagnosticSources");
+const semanticTokens_1 = require("./semanticTokens");
+const inlayHints_1 = require("./inlayHints");
 // Handle CLI flags before opening the LSP connection. Editor integrations
 // always spawn the server with `--stdio` and never pass these flags, so the
 // only callers that hit this branch are humans running the binary directly
@@ -47,6 +53,13 @@ const documents = new Map();
 const pendingValidations = new Map();
 let workspaceRoots = [];
 const rootScanStates = new Map();
+function isPathInsideRoot(filePath, root) {
+    const relative = path.relative(path.normalize(root), path.normalize(filePath));
+    return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function isInWorkspaceRoot(filePath) {
+    return workspaceRoots.some((root) => isPathInsideRoot(filePath, root));
+}
 /**
  * Check if the workspace use-graph is ready for the root containing a file.
  * Returns true if the root's scan is complete, false if scanning or idle.
@@ -55,12 +68,16 @@ const rootScanStates = new Map();
 function isUseGraphReadyForFile(filePath) {
     const normalized = path.normalize(filePath);
     for (const [root, state] of rootScanStates) {
-        if (normalized.startsWith(root))
+        if (isPathInsideRoot(normalized, root))
             return state === "ready";
     }
     // File outside all workspace roots — no graph needed, local scope is fine
     return true;
 }
+function getOpenDocumentContent(filePath) {
+    const uri = (0, url_1.pathToFileURL)(filePath).toString();
+    return getDocument(uri)?.getText();
+}
 /**
  * Async cooperative directory scanner. Discovers .ump files without blocking
  * the event loop. Uses fs.promises.readdir with yielding every 100 directories.
@@ -265,7 +282,15 @@ let supportsFileWatcherDynamicRegistration = false;
 const DEFAULT_UMPLESYNC_TIMEOUT_MS = 30000;
 // Track in-flight validations so we can abort stale ones
 const inFlightValidations = new Map();
+// Topic 054 — captured during initialize from
+// `params.capabilities.textDocument.completion.completionItem.snippetSupport`.
+// Snippet items are emitted only when this is true. Clients without snippet
+// support keep the pre-topic-054 keyword/symbol completion shape.
+let clientSnippetSupport = false;
 connection.onInitialize((params) => {
+    clientSnippetSupport =
+        params.capabilities.textDocument?.completion?.completionItem?.snippetSupport ===
+            true;
     const initOptions = params.initializationOptions;
     umpleSyncJarPath =
         initOptions?.umpleSyncJarPath || process.env.UMPLESYNC_JAR_PATH;
@@ -302,16 +327,49 @@ connection.onInitialize((params) => {
             textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
             completionProvider: {
                 resolveProvider: false,
-                triggerCharacters: ["/", "."],
+                // Stage-1 trigger expansion (topic 051 item 1).
+                //   "/"  use-path completion inside `use "..."`
+                //   "."  qualified names, dotted state paths
+                //   "-"  association arrow start (`1 -|`); trait-SM op marker
+                //   ","  isA / implementsReq / param continuation
+                // Stage-2 (topic 053):
+                //   "<"  association arrow `1 <|`; trait-SM op recovery `isA T<-|`
+                //   "@"  Java annotation (suppressed); aggregation `1 <@|`
+                //   "("  parameter-type slot at method (param-type completion)
+                // Topic 063:
+                //   " "  retrigger after structural whitespace slots (`1 |`,
+                //        `1 -> |`, `1 -> * |`, `implementsReq |`). We intentionally
+                //        do not trigger on token finishers (`>`, `*`) themselves; the
+                //        next slot starts after the separating space.
+                triggerCharacters: [...completionTriggers_1.COMPLETION_TRIGGER_CHARACTERS],
             },
             definitionProvider: true,
             referencesProvider: true,
+            // Topic 059 — `Go to Implementations` for traits. Returns
+            // class/trait declarations that implement the trait via `isA`,
+            // both directly and transitively (interfaces excluded).
+            implementationProvider: true,
             renameProvider: {
                 prepareProvider: true,
             },
             hoverProvider: true,
             documentSymbolProvider: true,
+            workspaceSymbolProvider: true,
+            semanticTokensProvider: {
+                legend: semanticTokens_1.UMPLE_SEMANTIC_TOKENS_LEGEND,
+                full: true,
+                range: false,
+            },
+            inlayHintProvider: {
+                resolveProvider: false,
+            },
             documentFormattingProvider: true,
+            // Quick-fix code actions. Pure classifiers live in codeActions.ts and
+            // are gated on compiler diagnostic codes plus shape whitelists.
+            codeActionProvider: {
+                codeActionKinds: [node_1.CodeActionKind.QuickFix],
+                resolveProvider: false,
+            },
         },
     };
 });
@@ -483,11 +541,17 @@ connection.onDidChangeWatchedFiles((params) => {
             symbolIndex_1.symbolIndex.removeFile(filePath);
         }
         else {
-            // Created or Changed — update use-graph edges from disk content
+            // Created or changed. If workspace/symbol has already indexed this file,
+            // keep symbols fresh; otherwise only maintain the lightweight use graph.
             const content = readFileSafe(filePath);
             if (content) {
-                const uses = symbolIndex_1.symbolIndex.extractUseStatements(filePath, content);
-                symbolIndex_1.symbolIndex.updateUseGraphEdges(filePath, uses);
+                if (symbolIndex_1.symbolIndex.isFileIndexed(filePath)) {
+                    symbolIndex_1.symbolIndex.indexFile(filePath, content);
+                }
+                else {
+                    const uses = symbolIndex_1.symbolIndex.extractUseStatements(filePath, content);
+                    symbolIndex_1.symbolIndex.updateUseGraphEdges(filePath, uses);
+                }
             }
         }
     }
@@ -512,6 +576,10 @@ connection.onCompletion(async (params) => {
     if (info.symbolKinds === "suppress") {
         return [];
     }
+    if (params.context?.triggerCharacter === " " &&
+        !(0, completionTriggers_1.shouldServeWhitespaceTriggeredCompletion)(info.symbolKinds)) {
+        return [];
+    }
     // 3. Ensure imported files are indexed
     const reachableFiles = ensureImportsIndexed(docPath, text);
     const items = [];
@@ -549,7 +617,7 @@ connection.onCompletion(async (params) => {
         }));
     }
     // 5. Build semantic completion items (keywords, operators, types, symbols)
-    const semanticItems = (0, completionBuilder_1.buildSemanticCompletionItems)(info, symbolKinds, symbolIndex_1.symbolIndex, reachableFiles);
+    const semanticItems = (0, completionBuilder_1.buildSemanticCompletionItems)(info, symbolKinds, symbolIndex_1.symbolIndex, reachableFiles, clientSnippetSupport);
     // Merge use_path items (if any) with semantic items, deduplicating
     for (const item of semanticItems) {
         if (!seen.has(item.label)) {
@@ -686,6 +754,67 @@ function isUnambiguousRename(symbols) {
     const name = symbols[0].name;
     return symbols.every((s) => s.name === name);
 }
+function shouldUseWorkspaceWideRename(docPath, symbols) {
+    return workspaceRoots.length > 0 &&
+        (isInWorkspaceRoot(docPath) || symbols.some((s) => isInWorkspaceRoot(s.file)));
+}
+function indexWorkspaceForRename() {
+    symbolIndex_1.symbolIndex.indexWorkspace(workspaceRoots, getOpenDocumentContent);
+    return symbolIndex_1.symbolIndex.getIndexedFilePaths();
+}
+function expandRenameDeclarations(resolvedSymbols, filesToSearch) {
+    if (resolvedSymbols.length === 0)
+        return [];
+    const target = resolvedSymbols[0];
+    const candidates = symbolIndex_1.symbolIndex.getSymbols({
+        name: target.name,
+        kind: target.kind,
+    });
+    return candidates.filter((candidate) => filesToSearch.has(path.normalize(candidate.file)) &&
+        candidate.name === target.name &&
+        candidate.kind === target.kind &&
+        isUnambiguousRename([...resolvedSymbols, candidate]));
+}
+// ── Find Implementations ─────────────────────────────────────────────────────
+// For class/interface/trait targets, return declarations below the target in
+// the `isA` graph. Trait behavior preserves topic 059 semantics: interfaces
+// are excluded and are not traversed for trait targets.
+connection.onImplementation(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document || !symbolIndexReady)
+        return [];
+    const docPath = getDocumentFilePath(document);
+    if (!docPath)
+        return [];
+    const resolved = resolveSymbolAtPosition(docPath, document.getText(), params.position.line, params.position.character);
+    if (!resolved)
+        return [];
+    const targetSymbols = resolved.symbols.filter((s) => s.kind === "class" || s.kind === "interface" || s.kind === "trait");
+    if (targetSymbols.length !== 1)
+        return [];
+    const target = targetSymbols[0];
+    // Same scope model as find-references: declaration files + forward
+    // import closure + reverse importers, lazily indexed.
+    const reachable = ensureImportsIndexed(docPath, document.getText());
+    const targetFiles = new Set([path.normalize(target.file)]);
+    for (const f of targetFiles)
+        reachable.add(f);
+    const reverseImporters = symbolIndex_1.symbolIndex.getReverseImporters(targetFiles);
+    for (const f of reverseImporters) {
+        if (!symbolIndex_1.symbolIndex.isFileIndexed(f)) {
+            try {
+                const content = fs.readFileSync(f, "utf8");
+                symbolIndex_1.symbolIndex.indexFile(f, content);
+            }
+            catch {
+                continue;
+            }
+        }
+        reachable.add(f);
+    }
+    const implementers = symbolIndex_1.symbolIndex.findIsAImplementers(target.name, target.kind, reachable);
+    return implementers.map((sym) => node_1.Location.create((0, url_1.pathToFileURL)(sym.file).toString(), node_1.Range.create(node_1.Position.create(sym.line, sym.column), node_1.Position.create(sym.endLine, sym.endColumn))));
+});
 connection.onPrepareRename(async (params) => {
     const document = getDocument(params.textDocument.uri);
     if (!document || !symbolIndexReady)
@@ -743,33 +872,39 @@ connection.onRenameRequest(async (params) => {
     // Validate new name against the kind-specific rule.
     if (!(0, renameValidation_1.isValidNewName)(resolved.symbols[0].kind, params.newName))
         return null;
-    // Check workspace use-graph readiness for the DECLARATION files' roots.
-    // Rename must not return partial WorkspaceEdits — if any declaration's
-    // root is still scanning, fail explicitly rather than silently miss importers.
-    // (Checked after resolution so we know which roots actually matter.)
-    for (const sym of resolved.symbols) {
-        if (!isUseGraphReadyForFile(sym.file)) {
-            // Use window/showMessage notification instead of showWarningMessage
-            // (window/showMessageRequest) — some clients like CodeMirror don't
-            // implement the request and the rejection crashes the server.
-            connection.sendNotification(node_1.ShowMessageNotification.type, {
-                type: node_1.MessageType.Warning,
-                message: "Workspace scan in progress. Please try rename again in a moment.",
-            });
-            return null;
+    const useWorkspaceWideRename = shouldUseWorkspaceWideRename(docPath, resolved.symbols);
+    // Check workspace use-graph readiness only for the old import-chain fallback.
+    // Workspace-wide rename indexes the workspace synchronously below, so it does
+    // not depend on the background use-graph scan having finished.
+    if (!useWorkspaceWideRename) {
+        for (const sym of resolved.symbols) {
+            if (!isUseGraphReadyForFile(sym.file)) {
+                // Use window/showMessage notification instead of showWarningMessage
+                // (window/showMessageRequest) — some clients like CodeMirror don't
+                // implement the request and the rejection crashes the server.
+                connection.sendNotification(node_1.ShowMessageNotification.type, {
+                    type: node_1.MessageType.Warning,
+                    message: "Workspace scan in progress. Please try rename again in a moment.",
+                });
+                return null;
+            }
         }
     }
-    // 2. Index forward-reachable files (fast, import-chain only — no workspace crawl).
-    // Same scope model as references: current file + forward imports + known reverse
-    // importers. See onReferences comment for full rationale.
+    // 2. Index forward-reachable files. If the rename target belongs to a
+    // workspace root, also synchronously index the workspace before searching.
+    // Rename is explicit and must prefer complete edits over request latency.
     const reachableFiles = ensureImportsIndexed(docPath, document.getText());
     // 3. Compute search scope: declaration files + forward-reachable + known reverse importers
     const declFiles = new Set(resolved.symbols.map((s) => path.normalize(s.file)));
+    const workspaceFiles = useWorkspaceWideRename
+        ? indexWorkspaceForRename()
+        : new Set();
     const reverseImporters = symbolIndex_1.symbolIndex.getReverseImporters(declFiles);
     const filesToSearch = new Set([
         ...declFiles,
         ...reachableFiles,
         ...reverseImporters,
+        ...workspaceFiles,
     ]);
     // Ensure reverse importers are fully indexed
     for (const file of reverseImporters) {
@@ -784,11 +919,15 @@ connection.onRenameRequest(async (params) => {
             }
         }
     }
-    // 4. Expand shared state declarations (reused SM alias/base equivalence)
-    const sharedDecls = symbolIndex_1.symbolIndex.getSharedStateDeclarations(resolved.symbols, filesToSearch);
-    // 5. Find ALL references including declarations
+    // 4. Expand declarations after the full search scope is known. This picks up
+    // same-identity declarations discovered by workspace indexing, such as
+    // partial top-level declarations in files outside the import graph.
+    const renameDeclarations = expandRenameDeclarations(resolved.symbols, filesToSearch);
+    // 5. Expand shared state declarations (reused SM alias/base equivalence)
+    const sharedDecls = symbolIndex_1.symbolIndex.getSharedStateDeclarations(renameDeclarations, filesToSearch);
+    // 6. Find ALL references including declarations
     const refs = symbolIndex_1.symbolIndex.findReferences(sharedDecls, filesToSearch, true);
-    // 5. Build WorkspaceEdit
+    // 7. Build WorkspaceEdit
     const changes = {};
     for (const r of refs) {
         const uri = (0, url_1.pathToFileURL)(r.file).toString();
@@ -841,6 +980,37 @@ connection.onDocumentSymbol(async (params) => {
     symbolIndex_1.symbolIndex.updateFile(docPath, document.getText());
     return (0, documentSymbolBuilder_1.buildDocumentSymbolTree)(symbolIndex_1.symbolIndex.getFileSymbols(docPath));
 });
+connection.onWorkspaceSymbol(async (params) => {
+    if (!symbolIndexReady)
+        return [];
+    if (workspaceRoots.length > 0) {
+        symbolIndex_1.symbolIndex.indexWorkspace(workspaceRoots, (filePath) => {
+            const uri = (0, url_1.pathToFileURL)(filePath).toString();
+            return getDocument(uri)?.getText();
+        });
+    }
+    return (0, workspaceSymbolBuilder_1.buildWorkspaceSymbols)(symbolIndex_1.symbolIndex.getAllSymbols(), params.query);
+});
+connection.languages.semanticTokens.on(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document || !symbolIndexReady)
+        return { data: [] };
+    const docPath = getDocumentFilePath(document);
+    if (!docPath)
+        return { data: [] };
+    symbolIndex_1.symbolIndex.updateFile(docPath, document.getText());
+    return (0, semanticTokens_1.buildSemanticTokens)(symbolIndex_1.symbolIndex.getHighlightCaptures(docPath));
+});
+connection.languages.inlayHint.on(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document || !symbolIndexReady)
+        return [];
+    const docPath = getDocumentFilePath(document);
+    if (!docPath)
+        return [];
+    symbolIndex_1.symbolIndex.updateFile(docPath, document.getText());
+    return (0, inlayHints_1.buildInlayHints)(symbolIndex_1.symbolIndex.getTree(docPath), params.range);
+});
 // ── Formatting ──────────────────────────────────────────────────────────────
 connection.onDocumentFormatting(async (params) => {
     const document = getDocument(params.textDocument.uri);
@@ -874,6 +1044,8 @@ connection.onDocumentFormatting(async (params) => {
         ...(0, formatter_1.computeIndentEdits)(text, params.options, formatTree),
         ...(0, formatter_1.fixTransitionSpacing)(text, formatTree),
         ...(0, formatter_1.fixAssociationSpacing)(text, formatTree),
+        ...(0, formatter_1.fixDeclarationAssignmentSpacing)(text, formatTree),
+        ...(0, formatter_1.fixStructuralCommaSpacing)(text, formatTree),
         ...(0, formatter_1.normalizeTopLevelBlankLines)(text, formatTree),
         ...(0, formatter_1.reindentEmbeddedCode)(text, params.options, formatTree),
     ];
@@ -925,6 +1097,14 @@ connection.onDocumentFormatting(async (params) => {
         node_1.TextEdit.replace(node_1.Range.create(node_1.Position.create(0, 0), node_1.Position.create(lastLine, lastChar)), finalText),
     ];
 });
+// Quick-fix code actions. Pure logic lives in `codeActions.ts`; this handler
+// just routes the diagnostics the client already received.
+connection.onCodeAction(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document)
+        return [];
+    return (0, codeActions_1.buildQuickFixActions)(document, params.context.diagnostics);
+});
 function scheduleValidation(document) {
     const uriKey = normalizeUri(document.uri);
     const existing = pendingValidations.get(uriKey);
@@ -1392,7 +1572,8 @@ function parseUmpleJsonDiagnostics(stderr, document, tempFilename, documentDir)
                         severity,
                         range: node_1.Range.create(node_1.Position.create(useLine, 0), node_1.Position.create(useLine, useLineText.length)),
                         message,
-                        source: "umple",
+                        source: diagnosticSources_1.UMPLE_DIAGNOSTIC_SOURCE,
+                        ...(errorCode ? { code: errorCode } : {}),
                     });
                 }
                 continue;
@@ -1402,18 +1583,17 @@ function parseUmpleJsonDiagnostics(stderr, document, tempFilename, documentDir)
             const lineText = lines[lineNumber] ?? "";
             const firstNonSpace = lineText.search(/\S/);
             const startChar = firstNonSpace === -1 ? 0 : firstNonSpace;
-            const details = [
-                result.errorCode
-                    ? (severity === node_1.DiagnosticSeverity.Warning ? "W" : "E") +
-                        result.errorCode
-                    : undefined,
-                result.message,
-            ].filter(Boolean);
+            const errorCode = result.errorCode
+                ? (severity === node_1.DiagnosticSeverity.Warning ? "W" : "E") +
+                    result.errorCode
+                : undefined;
+            const details = [errorCode, result.message].filter(Boolean);
             diagnostics.push({
                 severity,
                 range: node_1.Range.create(node_1.Position.create(lineNumber, startChar), node_1.Position.create(lineNumber, lineText.length)),
                 message: details.join(": "),
-                source: "umple",
+                source: diagnosticSources_1.UMPLE_DIAGNOSTIC_SOURCE,
+                ...(errorCode ? { code: errorCode } : {}),
             });
         }
         return diagnostics;