From 757b885f28d86e796153bd1cbc9e1c9c532680d6 Mon Sep 17 00:00:00 2001 From: Christoph Brandau Date: Mon, 21 Sep 2026 20:47:51 +0200 Subject: [PATCH 1/3] feat(server): index PSC scripts and provide cross-file TclOO navigation/completions Add PSC (.psc) indexing and share TclOO class metadata across files so class definitions discovered via PSC layers can be used for completions, signature help, inlay hints, and "go to definition". Key behavior changes: - Client file watcher now includes *.psc and .vscode launch paths/tests updated to use the postprocessor test folder; .gitignore updated to ignore that folder. - Server watches .psc changes and refreshes a PSC script index; new tools/tcloo_navigation.py exposes tcloo_definition used by the language server to resolve cross-file class/constructor/method definitions. - Language server uses class_snapshot(document.path) when producing TclOO completions, signature help, and inlay hints so resolved class metadata is available across files. Also includes related docs/changelog updates, minor code formatting cleanups, and added tests for PSC/TclOO behavior. --- .gitignore | 3 +- .vscode/launch.json | 8 +- CHANGELOG.md | 2 + README.md | 1 + client/src/common/handlers.ts | 26 +- client/src/common/server.ts | 2 +- server/src/lsp_server.py | 279 +++++++----------- server/src/lsp_tclserver.py | 79 +++++ server/src/tools/file_sourcing.py | 32 +- server/src/tools/inlay_hint.py | 4 +- server/src/tools/semantic_tokens.py | 46 ++- server/src/tools/tcl_command_completion.py | 180 +++-------- server/src/tools/tcloo_arguments.py | 4 +- server/src/tools/tcloo_completion.py | 61 +++- server/src/tools/tcloo_navigation.py | 35 +++ server/src/tools/tcloo_symbols.py | 10 +- .../python_tests/test_completion_context.py | 20 ++ server/tests/python_tests/test_psc_classes.py | 131 ++++++++ .../python_tests/test_tcloo_highlighting.py | 56 ++++ .../python_tests/test_tcloo_navigation.py | 94 ++++++ test/test.tcl | 4 + 21 files changed, 699 insertions(+), 378 deletions(-) create mode 100644 server/src/tools/tcloo_navigation.py create mode 100644 server/tests/python_tests/test_psc_classes.py create mode 100644 server/tests/python_tests/test_tcloo_highlighting.py create mode 100644 server/tests/python_tests/test_tcloo_navigation.py diff --git a/.gitignore b/.gitignore index c2b737c..37807b2 100644 --- a/.gitignore +++ b/.gitignore @@ -9,4 +9,5 @@ __pycache__ .nox *.g4 .antlr -.claude \ No newline at end of file +.claude +/test/postprocessor/ diff --git a/.vscode/launch.json b/.vscode/launch.json index 03d17d7..3083a79 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -13,7 +13,7 @@ "args": [ "--extensionDevelopmentPath=${env:TEMP}/nx-post-support-vscode-debug", "${env:TEMP}/nx-post-support-vscode-debug", - "${env:TEMP}/nx-post-support-vscode-debug/test/test.tcl" + "${env:TEMP}/nx-post-support-vscode-debug/test/postprocessor" ], "cwd": "${env:TEMP}/nx-post-support-vscode-debug", "outFiles": ["${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js"], @@ -21,7 +21,7 @@ "args": [ "--extensionDevelopmentPath=${workspaceFolder}", "${workspaceFolder}", - "${workspaceFolder}/test/test.tcl" + "${workspaceFolder}/test/postprocessor" ], "cwd": "${workspaceFolder}", "outFiles": ["${workspaceFolder}/dist/**/*.js"], @@ -59,7 +59,7 @@ "args": [ "--extensionDevelopmentPath=${env:TEMP}/nx-post-support-vscode-debug", "${env:TEMP}/nx-post-support-vscode-debug", - "${env:TEMP}/nx-post-support-vscode-debug/test/test.tcl" + "${env:TEMP}/nx-post-support-vscode-debug/test/postprocessor" ], "cwd": "${env:TEMP}/nx-post-support-vscode-debug", "outFiles": ["${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js"], @@ -67,7 +67,7 @@ "args": [ "--extensionDevelopmentPath=${workspaceFolder}", "${workspaceFolder}", - "${workspaceFolder}/test/test.tcl" + "${workspaceFolder}/test/postprocessor" ], "cwd": "${workspaceFolder}", "outFiles": ["${workspaceFolder}/dist/**/*.js"], diff --git a/CHANGELOG.md b/CHANGELOG.md index 27ab576..bd31eb8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,7 @@ ## Unreleased +- Add Go to Definition for TclOO classes, constructors, and resolved methods, including PSC library definitions +- Index PSC layer scripts (including external paths and legacy Windows encoding) and share TclOO class metadata across files for completion, signatures, inlay hints, and highlighting - Add document-local TclOO method completion for `new`/`create` instances, `my`, and statically inferred return chains - Suggest TclOO class names as classes and semantically highlight their declarations and calls - Show signature help and parameter inlay hints for resolved TclOO methods and constructors, including optional and variadic arguments diff --git a/README.md b/README.md index 9ccd5be..083ef00 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,7 @@ A comprehensive VS Code extension providing language support and remote debuggin - **Call Hierarchy** - Traces incoming and outgoing calls between custom TCL procedures and MOM event handlers - **Document Highlights** - Highlights all reads, writes, and calls of the symbol under the cursor - **Context-aware Completion** - Prioritizes local symbols and suggests variables, procedures, namespaces, paths, Tcl subcommands, valid argument values, and options based on cursor context +- **PSC and TclOO Classes** - Indexes Tcl scripts referenced by PSC layers, including external folders. Classes from indexed files provide method completion, signature help, parameter hints, and class highlighting in other files. PSC script names may omit `.tcl`; relative folders resolve from the PSC directory, and environment-variable folders are supported. Missing scripts are reported in the output channel; encrypted libraries cannot supply static class metadata. - **Tcl Snippets** - Inserts placeholder-based structures for `if`, `foreach`, `proc`, `switch`, `try`, and `dict for` - **NX Tcl Remote Debugger** - Breakpoints, stepping, call stack, scopes, variables, watches, evaluation, logpoints, hit conditions, and Tcl error stops directly in a running NX Post process diff --git a/client/src/common/handlers.ts b/client/src/common/handlers.ts index b196cff..d71aad9 100644 --- a/client/src/common/handlers.ts +++ b/client/src/common/handlers.ts @@ -1,8 +1,5 @@ import * as vscode from "vscode" -import { - cdlEventHandlerAtLine, - createCdlEventHandlerSnippet -} from "./cdlEventHandler" +import { cdlEventHandlerAtLine, createCdlEventHandlerSnippet } from "./cdlEventHandler" const MACHINE_HEADER_REGEX = /^MACHINE\s+\S+/ @@ -65,10 +62,7 @@ export function diagnosticHandler(document: vscode.TextDocument) { if (document.languageId === "cdl" || document.languageId === "def") { const text = document.getText() if (!isFirstLineMachine(text)) { - const range = new vscode.Range( - document.positionAt(0), - document.positionAt(text.length) - ) + const range = new vscode.Range(document.positionAt(0), document.positionAt(text.length)) const diagnostic = new vscode.Diagnostic( range, "The first line should contain 'MACHINE'.", @@ -82,7 +76,7 @@ export function diagnosticHandler(document: vscode.TextDocument) { export function completionHandlerCdl(document: vscode.TextDocument, position: vscode.Position) { const linePrefix = document.lineAt(position).text.substring(0, position.character) - const categories = ["MILL", "LATHE", "DRILL"] + const categories = ["MILL", "LATHE", "DRILL", "INVALID"] if (linePrefix.endsWith("TYPE ")) { return [ @@ -193,8 +187,7 @@ export async function definitionCdlEventHandler( .filter( (symbol) => symbol.kind === vscode.SymbolKind.Function && - (symbol.name === handlerName || - symbol.name.endsWith(`::${handlerName}`)) + (symbol.name === handlerName || symbol.name.endsWith(`::${handlerName}`)) ) .map((symbol) => symbol.location) if (indexedLocations.length > 0) { @@ -204,9 +197,7 @@ export async function definitionCdlEventHandler( // The Tcl language server may still be starting; use the file fallback below. } - const declaration = new RegExp( - `^\\s*proc\\s+(?:::)?${escapeRegExp(handlerName)}(?=\\s|\\{)` - ) + const declaration = new RegExp(`^\\s*proc\\s+(?:::)?${escapeRegExp(handlerName)}(?=\\s|\\{)`) const tclFiles = await vscode.workspace.findFiles( "**/*.tcl", "**/{.git,.nox,.venv,dist,node_modules,out}/**" @@ -233,12 +224,7 @@ export async function definitionCdlEventHandler( locations.push( new vscode.Location( uri, - new vscode.Range( - lineNumber, - start, - lineNumber, - start + handlerName.length - ) + new vscode.Range(lineNumber, start, lineNumber, start + handlerName.length) ) ) } diff --git a/client/src/common/server.ts b/client/src/common/server.ts index b943873..8b8300f 100644 --- a/client/src/common/server.ts +++ b/client/src/common/server.ts @@ -86,7 +86,7 @@ async function createServer( } // Options to control the language client - const tclFileWatcher = workspace.createFileSystemWatcher("**/*.tcl") + const tclFileWatcher = workspace.createFileSystemWatcher("**/*.{tcl,psc}") const clientOptions: LanguageClientOptions = { // Register the server for python documents documentSelector: isVirtualWorkspace() diff --git a/server/src/lsp_server.py b/server/src/lsp_server.py index 689b79b..4745b92 100644 --- a/server/src/lsp_server.py +++ b/server/src/lsp_server.py @@ -79,6 +79,7 @@ from tools.tcloo_arguments import method_signature_help from tclint.lexer import TclSyntaxError from tools.tcloo_completion import parse_completion_source, tcloo_completions from tools.tcloo_symbols import class_completion_items +from tools.tcloo_navigation import tcloo_definition from tools.tcl_command_completion import ( TCL_COMMAND_ITEMS, TCL_COMMAND_NAMES, @@ -92,40 +93,18 @@ GLOBAL_SETTINGS = {} MAX_WORKERS = 5 -LSP_SERVER = TclLanguageServer( - name="NX Postprocessor Support", version="0.0.1", max_workers=MAX_WORKERS -) +LSP_SERVER = TclLanguageServer(name="NX Postprocessor Support", version="0.0.1", max_workers=MAX_WORKERS) -BUILTIN_PROC_NAMES = { - item.label - for item in standard_items.tcl_keyword_list + standard_items.nx_procs -} | set(TCL_COMMAND_NAMES) +BUILTIN_PROC_NAMES = {item.label for item in standard_items.tcl_keyword_list + standard_items.nx_procs} | set(TCL_COMMAND_NAMES) BUILTIN_VARIABLE_NAMES = {item.label for item in standard_items.nx_variables} -_TCL_COMMAND_ITEMS_BY_LABEL = { - item.label: item for item in TCL_COMMAND_ITEMS -} -_TCL_KEYWORD_ITEMS = [ - _TCL_COMMAND_ITEMS_BY_LABEL.get(item.label, item) - for item in standard_items.tcl_keyword_list -] +_TCL_COMMAND_ITEMS_BY_LABEL = {item.label: item for item in TCL_COMMAND_ITEMS} +_TCL_KEYWORD_ITEMS = [_TCL_COMMAND_ITEMS_BY_LABEL.get(item.label, item) for item in standard_items.tcl_keyword_list] _STATIC_TCL_LABELS = {item.label for item in standard_items.tcl_keyword_list} -STATIC_COMPLETION_ITEMS = tuple( - _TCL_KEYWORD_ITEMS - + [item for item in TCL_COMMAND_ITEMS if item.label not in _STATIC_TCL_LABELS] - + standard_items.nx_procs - + standard_items.nx_variables -) -STATIC_VARIABLE_ITEMS = { - item.label: item for item in standard_items.nx_variables -} -BUILTIN_INLAY_SIGNATURES = build_builtin_inlay_signatures( - standard_items.json_data.get("MOM_procs", []) -) +STATIC_COMPLETION_ITEMS = tuple(_TCL_KEYWORD_ITEMS + [item for item in TCL_COMMAND_ITEMS if item.label not in _STATIC_TCL_LABELS] + standard_items.nx_procs + standard_items.nx_variables) +STATIC_VARIABLE_ITEMS = {item.label: item for item in standard_items.nx_variables} +BUILTIN_INLAY_SIGNATURES = build_builtin_inlay_signatures(standard_items.json_data.get("MOM_procs", [])) BUILTIN_HOVER_ITEMS = {} -for _hover_item in ( - standard_items.json_data.get("MOM_procs", []) - + standard_items.json_data.get("mom_variables", []) -): +for _hover_item in standard_items.json_data.get("MOM_procs", []) + standard_items.json_data.get("mom_variables", []): BUILTIN_HOVER_ITEMS.setdefault(_hover_item.get("label"), _hover_item) # ********************************************************** @@ -236,12 +215,23 @@ def did_rename_files(params: lsp.RenameFilesParams) -> None: def did_change_watched_files(params: lsp.DidChangeWatchedFilesParams) -> None: """Keep indexes for closed Tcl files synchronized with disk changes.""" for change in params.changes: + if pathlib.Path(uris.to_fs_path(change.uri)).suffix.lower() == ".psc": + _refresh_psc_index() + continue if change.type == lsp.FileChangeType.Deleted: LSP_SERVER.remove_file_state(change.uri) else: _index_tcl_file_from_disk(change.uri) +def _refresh_psc_index(): + folders = LSP_SERVER.workspace.folders + roots = [pathlib.Path(uris.to_fs_path(uri)) for uri in folders] + if not roots and LSP_SERVER.workspace.root_path: + roots = [pathlib.Path(LSP_SERVER.workspace.root_path)] + LSP_SERVER.refresh_psc_scripts(roots, report=log_warning) + + @LSP_SERVER.feature( lsp.TEXT_DOCUMENT_DIAGNOSTIC, lsp.DiagnosticOptions( @@ -255,9 +245,7 @@ def document_diagnostic(params: lsp.DocumentDiagnosticParams): uri = params.text_document.uri doc = LSP_SERVER.workspace.get_text_document(uri) diagnostic_state = LSP_SERVER.diagnostic_snapshot(uri) - was_cached = ( - diagnostic_state is not None and diagnostic_state[0] == doc.version - ) + was_cached = diagnostic_state is not None and diagnostic_state[0] == doc.version if not was_cached: LSP_SERVER.compute_diagnostics(doc) diagnostic_state = LSP_SERVER.diagnostic_snapshot(uri) @@ -282,11 +270,13 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: doc = LSP_SERVER.workspace.get_text_document(params.text_document.uri) position = params.position source_lines = LSP_SERVER.get_lines(doc) - oo_items = tcloo_completions(source_lines, position) + oo_items = tcloo_completions(source_lines, position, LSP_SERVER.class_snapshot(doc.path)) if oo_items is not None: return lsp.CompletionList(is_incomplete=False, items=oo_items) array_items = array_element_completions( - source_lines, position, LSP_SERVER.navigation_snapshot().values(), + source_lines, + position, + LSP_SERVER.navigation_snapshot().values(), str(pathlib.Path(uris.to_fs_path(doc.uri))), ) if array_items is not None: @@ -298,20 +288,14 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: argument_completion = None if context != CompletionContext.VARIABLE: argument_completion = tcl_argument_completion(source_lines, position) - if ( - argument_completion is not None - and argument_completion.dynamic_kind is None - ): + if argument_completion is not None and argument_completion.dynamic_kind is None: items = ranked_completion_items( ((0, item) for item in argument_completion.items), CompletionContext.GENERAL, ) return lsp.CompletionList(is_incomplete=False, items=items) - if ( - argument_completion is not None - and argument_completion.dynamic_kind == DynamicCompletionKind.PATH - ): + if argument_completion is not None and argument_completion.dynamic_kind == DynamicCompletionKind.PATH: dynamic_items: tuple[lsp.CompletionItem, ...] = () if doc.uri.startswith("file:"): document_path = pathlib.Path(uris.to_fs_path(doc.uri)) @@ -320,9 +304,7 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: argument_completion, position, ) - path_candidates = [ - (0, item) for item in argument_completion.items - ] + path_candidates = [(0, item) for item in argument_completion.items] path_candidates.extend((10, item) for item in dynamic_items) items = ranked_completion_items( path_candidates, @@ -335,8 +317,7 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: if ( argument_completion is None and params.context is not None - and params.context.trigger_kind - == lsp.CompletionTriggerKind.TriggerCharacter + and params.context.trigger_kind == lsp.CompletionTriggerKind.TriggerCharacter and params.context.trigger_character in {" ", "-", "(", ","} ): return lsp.CompletionList(is_incomplete=False, items=[]) @@ -347,9 +328,7 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: tree = parse_completion_source(doc.source) if tree is None: return lsp.CompletionList(is_incomplete=False, items=[]) - globals_set, procs_locals, proc_ranges = LSP_SERVER.variable_index_for_document( - doc, tree - ) + globals_set, procs_locals, proc_ranges = LSP_SERVER.variable_index_for_document(doc, tree) local_names: set[str] = set() for proc_range in proc_ranges: @@ -361,16 +340,14 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: candidates: list[tuple[int, lsp.CompletionItem]] = [] candidates.extend((0, item) for item in class_completion_items(tree)) for name in sorted(local_names - globals_set): - candidates.append( - ( - 0, - lsp.CompletionItem( - label=name, - kind=lsp.CompletionItemKind.Variable, - detail="Local variable", - ), - ) - ) + candidates.append(( + 0, + lsp.CompletionItem( + label=name, + kind=lsp.CompletionItemKind.Variable, + detail="Local variable", + ), + )) for name in sorted(globals_set): item = STATIC_VARIABLE_ITEMS.get(name) @@ -380,12 +357,10 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: kind=lsp.CompletionItemKind.Variable, detail="Workspace variable", ) - candidates.append( - ( - 100, - item, - ) - ) + candidates.append(( + 100, + item, + )) filepath = str(pathlib.Path(uris.to_fs_path(doc.uri))) items_by_file = LSP_SERVER.completion_items_by_file_snapshot() @@ -396,14 +371,15 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: if argument_completion is not None: static_candidates = [(0, item) for item in argument_completion.items] if argument_completion.dynamic_kind == DynamicCompletionKind.VARIABLE: - variable_candidates = [*static_candidates, *candidates] - variable_candidates.extend( - (300, item) for item in standard_items.nx_variables - ) + variable_candidates = list(candidates) + variable_candidates.extend((300, item) for item in standard_items.nx_variables) items = ranked_completion_items( variable_candidates, CompletionContext.VARIABLE, ) + # Command options are valid alongside variables, even though they + # are keywords and must not pass through the variable-only filter. + items = [*ranked_completion_items(static_candidates, CompletionContext.GENERAL), *items] return lsp.CompletionList(is_incomplete=False, items=items) if argument_completion.dynamic_kind == DynamicCompletionKind.PROCEDURE: @@ -412,14 +388,8 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: lsp.CompletionItemKind.Function, lsp.CompletionItemKind.Method, } - procedure_candidates = [ - (priority, item) - for priority, item in candidates - if item.kind in procedure_kinds - ] - procedure_candidates.extend( - (300, item) for item in standard_items.nx_procs - ) + procedure_candidates = [(priority, item) for priority, item in candidates if item.kind in procedure_kinds] + procedure_candidates.extend((300, item) for item in standard_items.nx_procs) items = ranked_completion_items( [*static_candidates, *procedure_candidates], CompletionContext.GENERAL, @@ -430,26 +400,20 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: namespace_candidates = list(static_candidates) prefix_is_absolute = argument_completion.active_prefix.startswith("::") for index in LSP_SERVER.navigation_snapshot().values(): - priority = ( - 100 - if LSP_SERVER.paths_equal(index.path, filepath) - else 200 - ) + priority = 100 if LSP_SERVER.paths_equal(index.path, filepath) else 200 for occurrence in index.occurrences: if occurrence.identity.kind != "namespace": continue name = occurrence.identity.name label = name if prefix_is_absolute else name.removeprefix("::") - namespace_candidates.append( - ( - priority, - lsp.CompletionItem( - label=label, - kind=lsp.CompletionItemKind.Module, - detail="Tcl namespace", - ), - ) - ) + namespace_candidates.append(( + priority, + lsp.CompletionItem( + label=label, + kind=lsp.CompletionItemKind.Module, + detail="Tcl namespace", + ), + )) items = ranked_completion_items( namespace_candidates, CompletionContext.GENERAL, @@ -470,7 +434,7 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList: ) def signature_help(params: lsp.SignatureHelpParams) -> lsp.SignatureHelp | None: document = LSP_SERVER.workspace.get_text_document(params.text_document.uri) - method_help = method_signature_help(document.source, params.position) + method_help = method_signature_help(document.source, params.position, LSP_SERVER.class_snapshot(document.path)) if method_help is not None: return method_help try: @@ -480,9 +444,7 @@ def signature_help(params: lsp.SignatureHelpParams) -> lsp.SignatureHelp | None: if tree is None: return None - custom_signatures, custom_docs = LSP_SERVER.proc_metadata_snapshot( - document.path - ) + custom_signatures, custom_docs = LSP_SERVER.proc_metadata_snapshot(document.path) return build_signature_help( document.source, @@ -528,20 +490,17 @@ def inlay_hints(params: lsp.InlayHintParams): # Built-in NX procedures are the fallback. Workspace procedures replace them, # and a declaration in the current file wins over duplicate workspace names. - custom_signatures = LSP_SERVER.custom_inlay_signatures_snapshot( - document.path - ) + custom_signatures = LSP_SERVER.custom_inlay_signatures_snapshot(document.path) signatures = ChainMap(custom_signatures, BUILTIN_INLAY_SIGNATURES) generator = InlayHintGenerator( document.source, signatures, + external_classes=LSP_SERVER.class_snapshot(document.path), source_lines=LSP_SERVER.get_lines(document), requested_range=params.range, parameter_names=parameter_names, - suppress_when_argument_matches_name=inlay_settings.get( - "suppressWhenArgumentMatchesName", True - ), + suppress_when_argument_matches_name=inlay_settings.get("suppressWhenArgumentMatchesName", True), ) return generator.generate(tree) @@ -562,20 +521,20 @@ def semantic_tokens(params: lsp.SemanticTokensParams): # Reuse cached AST tree = LSP_SERVER.get_tree(document) - hl.highlight_classes(tree) + classes = LSP_SERVER.class_snapshot(document.path) + hl.highlight_classes(tree, classes) + hl.highlight_methods(tree, document.source, document.uri, classes) tree.accept(hl, recurse=True) tokens = hl.tokens() for token in tokens: - data.extend( - [ - token.line, - token.offset, - token.length, - TOKEN_TYPE_INDEX[token.tok_type], - reduce(operator.or_, token.tok_modifiers, 0), - ] - ) + data.extend([ + token.line, + token.offset, + token.length, + TOKEN_TYPE_INDEX[token.tok_type], + reduce(operator.or_, token.tok_modifiers, 0), + ]) return lsp.SemanticTokens(data=data) @@ -617,9 +576,7 @@ def hover(params: lsp.HoverParams) -> lsp.Hover: if match and match.get("kind") == "function": label = match.get("label", "") parameters = match.get("parameters", []) - param_lines = ( - "\n".join(f"- `{p['name']}`: {p['desc']}" for p in parameters) or "_None_" - ) + param_lines = "\n".join(f"- `{p['name']}`: {p['desc']}" for p in parameters) or "_None_" example_data = match.get("example", []) example_md = "\n".join(f"{line}" for line in example_data) returns_data = match.get("returns", ["None"]) @@ -648,28 +605,30 @@ def hover(params: lsp.HoverParams) -> lsp.Hover: # Build a merged map of proc -> docs gathered during initialization and updates proc_doc = LSP_SERVER.proc_documentation(token, document.path) if proc_doc is not None: - return lsp.Hover( - lsp.MarkupContent(kind=lsp.MarkupKind.Markdown, value=proc_doc) - ) + return lsp.Hover(lsp.MarkupContent(kind=lsp.MarkupKind.Markdown, value=proc_doc)) return None @LSP_SERVER.feature(lsp.TEXT_DOCUMENT_DEFINITION) def goto_definition(params: lsp.DefinitionParams): - """Resolve Tcl proc and variable definitions through the symbol index.""" + """Resolve TclOO declarations, then indexed proc and variable definitions.""" + try: + workspace = LSP_SERVER.workspace + except RuntimeError: + workspace = None + if workspace is not None: + document = workspace.get_text_document(params.text_document.uri) + target = tcloo_definition(document.source, document.uri, params.position, + LSP_SERVER.class_snapshot(document.path)) + if target is not None: + return [target] context = _navigation_context(params.text_document.uri, params.position) if context is None: return None indexes, definitions, _, identity = context - locations = [ - lsp.Location(uri=index.uri, range=occurrence.range) - for index, occurrence in matching_occurrences( - identity, indexes, definitions - ) - if occurrence.is_definition - ] + locations = [lsp.Location(uri=index.uri, range=occurrence.range) for index, occurrence in matching_occurrences(identity, indexes, definitions) if occurrence.is_definition] return _sorted_locations(locations) or None @@ -713,9 +672,7 @@ def references(params: lsp.ReferenceParams) -> list[lsp.Location]: indexes, definitions, _, identity = context locations = [ lsp.Location(uri=index.uri, range=occurrence.range) - for index, occurrence in matching_occurrences( - identity, indexes, definitions - ) + for index, occurrence in matching_occurrences(identity, indexes, definitions) if params.context.include_declaration or not occurrence.is_definition ] return _sorted_locations(locations) @@ -747,11 +704,7 @@ def _is_renamable( if identity.kind == "proc": if basename in BUILTIN_PROC_NAMES: return False - definition_count = sum( - occurrence.is_definition and occurrence.identity == identity - for index in indexes.values() - for occurrence in index.occurrences - ) + definition_count = sum(occurrence.is_definition and occurrence.identity == identity for index in indexes.values() for occurrence in index.occurrences) return definition_count == 1 return basename not in BUILTIN_VARIABLE_NAMES @@ -766,9 +719,7 @@ def prepare_rename(params: lsp.PrepareRenameParams): indexes, definitions, occurrence, identity = context if not _is_renamable(identity, indexes, definitions): return None - return lsp.PrepareRenamePlaceholder( - range=occurrence.range, placeholder=occurrence.placeholder - ) + return lsp.PrepareRenamePlaceholder(range=occurrence.range, placeholder=occurrence.placeholder) @LSP_SERVER.feature( @@ -800,9 +751,7 @@ def rename(params: lsp.RenameParams) -> lsp.WorkspaceEdit | None: if key in seen: continue seen.add(key) - changes.setdefault(index.uri, []).append( - lsp.TextEdit(range=occurrence.range, new_text=params.new_name) - ) + changes.setdefault(index.uri, []).append(lsp.TextEdit(range=occurrence.range, new_text=params.new_name)) for edits in changes.values(): edits.sort( @@ -913,12 +862,8 @@ def initialize(params: lsp.InitializeParams) -> lsp.InitializeResult: settings = params.initialization_options["settings"] _update_workspace_settings(settings) - log_to_output( - f"Settings used to run Server:\r\n{json.dumps(settings, indent=4, ensure_ascii=False)}\r\n" - ) - log_to_output( - f"Global settings:\r\n{json.dumps(GLOBAL_SETTINGS, indent=4, ensure_ascii=False)}\r\n" - ) + log_to_output(f"Settings used to run Server:\r\n{json.dumps(settings, indent=4, ensure_ascii=False)}\r\n") + log_to_output(f"Global settings:\r\n{json.dumps(GLOBAL_SETTINGS, indent=4, ensure_ascii=False)}\r\n") semantic_tokens_legend = lsp.SemanticTokensLegend( token_types=TOKEN_TYPES, token_modifiers=[m.name for m in TokenModifier], @@ -927,9 +872,7 @@ def initialize(params: lsp.InitializeParams) -> lsp.InitializeResult: capabilities=lsp.ServerCapabilities( document_formatting_provider=GLOBAL_SETTINGS.get("formatter", True), folding_range_provider=True, - semantic_tokens_provider=lsp.SemanticTokensOptions( - legend=semantic_tokens_legend, full=True, range=False - ), + semantic_tokens_provider=lsp.SemanticTokensOptions(legend=semantic_tokens_legend, full=True, range=False), definition_provider=True, document_highlight_provider=True, references_provider=True, @@ -963,19 +906,10 @@ def initialized(_params: lsp.InitializedParams): "node_modules", "out", } - tcl_files = ( - path - for path in root_path.rglob("*.tcl") - if not any( - part.casefold() in skipped_directories - for part in path.relative_to(root_path).parts[:-1] - ) - ) + tcl_files = (path for path in root_path.rglob("*.tcl") if not any(part.casefold() in skipped_directories for part in path.relative_to(root_path).parts[:-1])) for filepath in sorted(tcl_files, key=lambda path: str(path).casefold()): try: - document = TextDocument( - uri=filepath.as_uri(), language_id="tcl" - ) + document = TextDocument(uri=filepath.as_uri(), language_id="tcl") LSP_SERVER.update_poco_completion_for_file( document, cache_tree=False, @@ -983,6 +917,7 @@ def initialized(_params: lsp.InitializedParams): ) except Exception as error: log_to_output(f"Fehler beim Parsen von {filepath}: {error}") + _refresh_psc_index() log_to_output("Background indexing completed.") except Exception as e: log_to_output(f"Background indexing failed: {e}") @@ -1089,36 +1024,26 @@ def _get_settings_by_document(document: TextDocument | None): # ***************************************************** # Logging and notification. # ***************************************************** -def log_to_output( - message: str, msg_type: lsp.MessageType = lsp.MessageType.Log -) -> None: - LSP_SERVER.window_log_message( - lsp.LogMessageParams(message=message, type=msg_type) - ) +def log_to_output(message: str, msg_type: lsp.MessageType = lsp.MessageType.Log) -> None: + LSP_SERVER.window_log_message(lsp.LogMessageParams(message=message, type=msg_type)) def log_error(message: str) -> None: log_to_output(message, lsp.MessageType.Error) if os.getenv("LS_SHOW_NOTIFICATION", "off") in ["onError", "onWarning", "always"]: - LSP_SERVER.window_show_message( - lsp.ShowMessageParams(message=message, type=lsp.MessageType.Error) - ) + LSP_SERVER.window_show_message(lsp.ShowMessageParams(message=message, type=lsp.MessageType.Error)) def log_warning(message: str) -> None: log_to_output(message, lsp.MessageType.Warning) if os.getenv("LS_SHOW_NOTIFICATION", "off") in ["onWarning", "always"]: - LSP_SERVER.window_show_message( - lsp.ShowMessageParams(message=message, type=lsp.MessageType.Warning) - ) + LSP_SERVER.window_show_message(lsp.ShowMessageParams(message=message, type=lsp.MessageType.Warning)) def log_always(message: str) -> None: log_to_output(message, lsp.MessageType.Info) if os.getenv("LS_SHOW_NOTIFICATION", "off") in ["always"]: - LSP_SERVER.window_show_message( - lsp.ShowMessageParams(message=message, type=lsp.MessageType.Info) - ) + LSP_SERVER.window_show_message(lsp.ShowMessageParams(message=message, type=lsp.MessageType.Info)) # ***************************************************** diff --git a/server/src/lsp_tclserver.py b/server/src/lsp_tclserver.py index 77ff4f0..3b41f55 100644 --- a/server/src/lsp_tclserver.py +++ b/server/src/lsp_tclserver.py @@ -2,6 +2,7 @@ import logging import os import pathlib import threading +import xml.etree.ElementTree as ET from typing import List, Optional, Tuple import lsprotocol.types as lsp @@ -15,6 +16,8 @@ from tclint.violations import Violation from tools import checks, parser from tools.completion_items import CompletionCollector from tools.tcloo_symbols import class_completion_items +from tools.tcloo_completion import indexed_classes +from tools.file_sourcing import get_all_psc_files, psc_script_files from tools.formatter import NxFormatter as Formatter from tools.inlay_hint import InlayHintSignature, build_custom_inlay_signatures from tools.navigation import FileSymbolIndex, build_file_symbol_index @@ -35,6 +38,10 @@ class TclLanguageServer(LanguageServer): self.poco_completion: dict = {} self.proc_signatures: dict = {} self.proc_docs: dict = {} + self.class_indexes: dict = {} + self.psc_script_paths: list[str] = [] + self._psc_files: dict[str, list[pathlib.Path]] = {} + self._psc_lock = threading.RLock() self.navigation_indexes: dict[str, FileSymbolIndex] = {} self.variable_indexes: dict[ str, @@ -171,6 +178,74 @@ class TclLanguageServer(LanguageServer): self._workspace_completion_cache = (self._index_generation, items) return items + def class_snapshot(self, current_path) -> dict: + """Share class metadata, without stale definitions from the active file. + + PSC scripts override other workspace files in their listed load order. + The request parser adds the current document's declarations last. + """ + with self._index_lock: + indexes = {self._normalized_path(path): classes for path, classes in self.class_indexes.items()} + paths = sorted(self.class_indexes, key=str.casefold) + psc_paths = {self._normalized_path(path) for path in self.psc_script_paths} + paths = [path for path in paths if self._normalized_path(path) not in psc_paths] + paths.extend(self.psc_script_paths) + classes = {} + for path in paths: + if not self.paths_equal(path, current_path): + classes.update(indexes.get(self._normalized_path(path), {})) + return classes + + def refresh_psc_scripts(self, roots, report=LOGGER.warning): + """Index PSC dependencies through the same pipeline as workspace procs.""" + with self._psc_lock: + discovered = {} + for root in roots: + for psc in get_all_psc_files(root): + try: + discovered[str(psc)] = psc_script_files(psc) + except (OSError, ET.ParseError) as error: + report(f"Could not read PSC {psc}: {error}") + discovered[str(psc)] = self._psc_files.get(str(psc), []) + paths = [str(path) for scripts in discovered.values() for path in scripts] + with self._index_lock: + previous = set(self.psc_script_paths) + self.psc_script_paths = paths + self._psc_files = discovered + try: + open_documents = { + self._normalized_path(document.path): document + for document in self.workspace.text_documents.values() + } + except RuntimeError: + open_documents = {} + for removed in previous - set(paths): + path = pathlib.Path(removed) + if (not any(self._is_same_or_child(path, root) for root in roots) + and self._normalized_path(path) not in open_documents): + self.remove_file_state(path.as_uri()) + for path_string in dict.fromkeys(paths): + path = pathlib.Path(path_string) + uri = path.as_uri() + document = open_documents.get(self._normalized_path(path)) + if document is None and not path.is_file(): + self.remove_file_state(uri) + report(f"PSC script not found: {path}") + continue + try: + if document is None: + data = path.read_bytes() + try: + source = data.decode("utf-8-sig") + except UnicodeDecodeError: + # Older Windows NX layers use the ANSI code page. + source = data.decode("cp1252") + document = TextDocument(uri=uri, source=source, language_id="tcl") + if not self.update_poco_completion_for_file(document, cache_tree=False): + report(f"Could not index PSC script: {path}") + except (OSError, UnicodeError) as error: + report(f"Could not read PSC script {path}: {error}") + def completion_items_by_file_snapshot( self, ) -> dict[str, tuple[lsp.CompletionItem, ...]]: @@ -455,6 +530,7 @@ class TclLanguageServer(LanguageServer): self.poco_completion.pop(filepath, None) self.proc_signatures.pop(filepath, None) self.proc_docs.pop(filepath, None) + self.class_indexes.pop(filepath, None) self.navigation_indexes.pop(filepath, None) self.variable_indexes.pop(filepath, None) self._committed_index_versions.pop(filepath, None) @@ -486,6 +562,7 @@ class TclLanguageServer(LanguageServer): self.poco_completion, self.proc_signatures, self.proc_docs, + self.class_indexes, self.navigation_indexes, self.variable_indexes, self._index_tokens, @@ -545,6 +622,7 @@ class TclLanguageServer(LanguageServer): ) tree.accept(collector, recurse=True) collector.custom_functions.extend(class_completion_items(tree)) + classes = indexed_classes(tree, document.uri, document.source) docs = build_proc_docs(tree, document.source) navigation_index = build_file_symbol_index( filepath, document.uri, tree @@ -565,6 +643,7 @@ class TclLanguageServer(LanguageServer): self.poco_completion[filepath] = list(collector.custom_functions) self.proc_signatures[filepath] = dict(collector.proc_signatures) self.proc_docs[filepath] = docs + self.class_indexes[filepath] = classes self.navigation_indexes[filepath] = navigation_index self.variable_indexes[filepath] = (document.version, variable_index) self._committed_index_versions[filepath] = document.version diff --git a/server/src/tools/file_sourcing.py b/server/src/tools/file_sourcing.py index 8db75b3..936c30a 100644 --- a/server/src/tools/file_sourcing.py +++ b/server/src/tools/file_sourcing.py @@ -1,4 +1,5 @@ import xml.etree.ElementTree as ET +import os from dataclasses import dataclass from typing import List, Optional from pathlib import Path @@ -14,6 +15,9 @@ class SourcedFile: def read_psc_file(psc_file: Path) -> List[SourcedFile]: tree = ET.parse(psc_file) root = tree.getroot() + # PSC exports may use a default XML namespace. + for element in root.iter(): + element.tag = element.tag.rsplit("}", 1)[-1] layers = root.findall(".//Layer") @@ -37,15 +41,23 @@ def read_psc_file(psc_file: Path) -> List[SourcedFile]: def get_all_psc_files(root_path: Path) -> list[Path]: - return [path for path in root_path.rglob("*.psc")] + return sorted(root_path.rglob("*.psc"), key=lambda path: str(path).casefold()) -if __name__ == "__main__": - test = get_all_psc_files( - Path( - r"H:\janus-engineering-customers\KSB_Frankenthal\custom\library\machine\installed_machines\ksb_pe_grob_g550_sone\postprocessor" - ) - ) - print(test) - for pp in test: - read_psc_file(pp) +def psc_script_files(psc_file: Path) -> list[Path]: + """Resolve layer script paths relative to the PSC, preserving load order.""" + def expanded(value): + return Path(os.path.expandvars(value).replace("\\", "/")) + + paths = [] + for layer in read_psc_file(psc_file): + folder = layer.subfolder or "." + base = psc_file.parent / expanded(os.environ.get(folder, folder)) + for name in layer.files: + filename = expanded(name) + if not filename.suffix: + filename = filename.with_suffix(".tcl") + path = (base / filename).resolve() + if path.suffix.lower() == ".tcl": + paths.append(path) + return paths diff --git a/server/src/tools/inlay_hint.py b/server/src/tools/inlay_hint.py index 40e8091..a9063c2 100644 --- a/server/src/tools/inlay_hint.py +++ b/server/src/tools/inlay_hint.py @@ -158,11 +158,13 @@ class InlayHintGenerator(Visitor): requested_range: lsp.Range | None = None, parameter_names: str = "all", suppress_when_argument_matches_name: bool = True, + external_classes=None, ): self.source_lines = ( source_lines if source_lines is not None else source.splitlines() ) self.source = source + self.external_classes = external_classes self.proc_signatures = proc_signatures self.requested_range = requested_range self.parameter_names = parameter_names @@ -198,7 +200,7 @@ class InlayHintGenerator(Visitor): walk(tree) if self.parameter_names != "none": - for call in resolved_method_calls(self.source): + for call in resolved_method_calls(self.source, self.external_classes): if not self._node_intersects_requested_range(call.command): continue parameters = method_parameters(call.parameters) diff --git a/server/src/tools/semantic_tokens.py b/server/src/tools/semantic_tokens.py index f2163e0..fa67bb8 100644 --- a/server/src/tools/semantic_tokens.py +++ b/server/src/tools/semantic_tokens.py @@ -7,6 +7,7 @@ from tclint.commands.plugins import PluginManager from tclint.syntax_tree import BareWord, Command, QuotedWord, Visitor from tools.variable_names import variable_name from tools.tcloo_symbols import class_symbols +from tools.tcloo_completion import _analyze # Constructing a PluginManager scans entry points, and get_commands() rebuilds # the builtin command set on every call. Semantic tokens are requested often, so @@ -72,12 +73,9 @@ class _Highlighter(Visitor): self._commands = _load_commands(plugins) self._tokens = [] self._class_tokens = {} + self._method_tokens = {} if isinstance(custom_functions, dict): - self._custom_function_names = frozenset( - item.label - for items in custom_functions.values() - for item in items - ) + self._custom_function_names = frozenset(item.label for items in custom_functions.values() for item in items) else: self._custom_function_names = frozenset(custom_functions) @@ -86,15 +84,18 @@ class _Highlighter(Visitor): return self._tokens.append((position, length, tok_type, modifiers or [])) - def highlight_classes(self, tree): - declarations, references = class_symbols(tree) + def highlight_classes(self, tree, external_classes=None): + declarations, references = class_symbols(tree, external_classes) for node, modifiers in [ *((node, [TokenModifier.declaration]) for node in declarations.values()), *((node, []) for node in references), ]: line, col = node.contents_pos self._class_tokens[(line - 1, col - 1)] = ( - (line - 1, col - 1), len(node.contents), "class", modifiers, + (line - 1, col - 1), + len(node.contents), + "class", + modifiers, ) def _get_token_info(self, node): @@ -124,6 +125,28 @@ class _Highlighter(Visitor): return None + def highlight_methods(self, tree, source, uri, external_classes=None): + """Use the same function token as procs for resolved TclOO methods.""" + classes, _, calls = _analyze(tree, external_classes=external_classes, uri=uri, source=source) + lines = source.splitlines() + for info in classes.values(): + for location in info.method_definitions.values(): + if location.uri != uri: + continue + start, end = location.range.start, location.range.end + encoded = lines[start.line].encode("utf-16-le") + column = len(encoded[:start.character * 2].decode("utf-16-le")) + length = len(encoded[start.character * 2:end.character * 2].decode("utf-16-le")) + position = (start.line, column) + self._method_tokens[position] = (position, length, "function", [TokenModifier.declaration]) + for call in calls: + node = call.command.args[0] + if node.contents is None or node.contents_pos is None: + continue + line, column = node.contents_pos + position = (line - 1, column - 1) + self._method_tokens[position] = (position, len(node.contents), "function", []) + def visit_quoted_word(self, word: QuotedWord): if not word.contents: return @@ -170,7 +193,7 @@ class _Highlighter(Visitor): if routine.contents == "puts": line, col = routine.contents_pos self._append_token((line - 1, col - 1), len(routine.contents), "function", [TokenModifier.builtin]) - if routine.contents == "set" and command.args: + if routine.contents in ["set", "append", "lappend"] and command.args: first_arg = command.args[0] token_info = self._get_token_info(first_arg) if first_arg.contents is None: @@ -217,8 +240,9 @@ class _Highlighter(Visitor): tokens = [] last_line = 0 last_col = 0 - raw_tokens = [token for token in self._tokens if token[0] not in self._class_tokens] - raw_tokens.extend(self._class_tokens.values()) + overrides = {**self._method_tokens, **self._class_tokens} + raw_tokens = [token for token in self._tokens if token[0] not in overrides] + raw_tokens.extend(overrides.values()) for (line, col), length, tok_type, tok_modifier in sorted(raw_tokens, key=lambda x: x[0]): line_delta = line - last_line col_delta = col diff --git a/server/src/tools/tcl_command_completion.py b/server/src/tools/tcl_command_completion.py index b96caeb..b560225 100644 --- a/server/src/tools/tcl_command_completion.py +++ b/server/src/tools/tcl_command_completion.py @@ -284,6 +284,7 @@ def _options(*labels: str) -> tuple[OptionSpec, ...]: OPTIONS_BY_PATH: dict[tuple[str, ...], tuple[OptionSpec, ...]] = { + ("unset",): _options("nocomplain"), ("binary", "decode", "base64"): (OptionSpec("-strict"),), ("binary", "encode", "base64"): ( OptionSpec("-maxlen", takes_value=True), @@ -437,109 +438,51 @@ _REPEATED_SUBCOMMAND_ARGUMENTS = frozenset(range(2, 33)) DYNAMIC_COMPLETION_RULES = ( # Variable-taking commands. DynamicCompletionRule(("append",), frozenset({1}), DynamicCompletionKind.VARIABLE), - DynamicCompletionRule( - ("array", "exists"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("array", "get"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("array", "names"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("array", "set"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("array", "size"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("array", "statistics"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("array", "unset"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("catch",), frozenset({2, 3}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("dict", "append"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("dict", "incr"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("dict", "lappend"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("dict", "set"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("dict", "unset"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("dict", "update"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("dict", "with"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("global",), _REPEATED_ARGUMENTS, DynamicCompletionKind.VARIABLE - ), + DynamicCompletionRule(("array", "exists"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("array", "get"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("array", "names"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("array", "set"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("array", "size"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("array", "statistics"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("array", "unset"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("catch",), frozenset({2, 3}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("dict", "append"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("dict", "incr"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("dict", "lappend"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("dict", "set"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("dict", "unset"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("dict", "update"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("dict", "with"), frozenset({2}), DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("global",), _REPEATED_ARGUMENTS, DynamicCompletionKind.VARIABLE), DynamicCompletionRule(("incr",), frozenset({1}), DynamicCompletionKind.VARIABLE), - DynamicCompletionRule( - ("info", "exists"), frozenset({2}), DynamicCompletionKind.VARIABLE - ), + DynamicCompletionRule(("info", "exists"), frozenset({2}), DynamicCompletionKind.VARIABLE), DynamicCompletionRule(("lappend",), frozenset({1}), DynamicCompletionKind.VARIABLE), DynamicCompletionRule(("set",), frozenset({1}), DynamicCompletionKind.VARIABLE), - DynamicCompletionRule( - ("unset",), _REPEATED_ARGUMENTS, DynamicCompletionKind.VARIABLE - ), - DynamicCompletionRule( - ("variable",), frozenset({1}), DynamicCompletionKind.VARIABLE - ), + DynamicCompletionRule(("unset",), _REPEATED_ARGUMENTS, DynamicCompletionKind.VARIABLE), + DynamicCompletionRule(("variable",), frozenset({1}), DynamicCompletionKind.VARIABLE), DynamicCompletionRule(("vwait",), frozenset({1}), DynamicCompletionKind.VARIABLE), # Procedure-taking commands. - DynamicCompletionRule( - ("info", "args"), frozenset({2}), DynamicCompletionKind.PROCEDURE - ), - DynamicCompletionRule( - ("info", "body"), frozenset({2}), DynamicCompletionKind.PROCEDURE - ), - DynamicCompletionRule( - ("info", "default"), frozenset({2}), DynamicCompletionKind.PROCEDURE - ), - DynamicCompletionRule( - ("namespace", "origin"), frozenset({2}), DynamicCompletionKind.PROCEDURE - ), + DynamicCompletionRule(("info", "args"), frozenset({2}), DynamicCompletionKind.PROCEDURE), + DynamicCompletionRule(("info", "body"), frozenset({2}), DynamicCompletionKind.PROCEDURE), + DynamicCompletionRule(("info", "default"), frozenset({2}), DynamicCompletionKind.PROCEDURE), + DynamicCompletionRule(("namespace", "origin"), frozenset({2}), DynamicCompletionKind.PROCEDURE), DynamicCompletionRule(("rename",), frozenset({1}), DynamicCompletionKind.PROCEDURE), # Namespace-taking commands. - DynamicCompletionRule( - ("namespace", "children"), frozenset({2}), DynamicCompletionKind.NAMESPACE - ), + DynamicCompletionRule(("namespace", "children"), frozenset({2}), DynamicCompletionKind.NAMESPACE), DynamicCompletionRule( ("namespace", "delete"), _REPEATED_SUBCOMMAND_ARGUMENTS, DynamicCompletionKind.NAMESPACE, ), - DynamicCompletionRule( - ("namespace", "eval"), frozenset({2}), DynamicCompletionKind.NAMESPACE - ), - DynamicCompletionRule( - ("namespace", "exists"), frozenset({2}), DynamicCompletionKind.NAMESPACE - ), - DynamicCompletionRule( - ("namespace", "parent"), frozenset({2}), DynamicCompletionKind.NAMESPACE - ), + DynamicCompletionRule(("namespace", "eval"), frozenset({2}), DynamicCompletionKind.NAMESPACE), + DynamicCompletionRule(("namespace", "exists"), frozenset({2}), DynamicCompletionKind.NAMESPACE), + DynamicCompletionRule(("namespace", "parent"), frozenset({2}), DynamicCompletionKind.NAMESPACE), # Path-taking commands. Source files are narrowed to Tcl while directories # remain visible so users can continue navigating. DynamicCompletionRule(("cd",), frozenset({1}), DynamicCompletionKind.PATH), - DynamicCompletionRule( - ("load",), frozenset({1}), DynamicCompletionKind.PATH, (".dll", ".so", ".dylib") - ), + DynamicCompletionRule(("load",), frozenset({1}), DynamicCompletionKind.PATH, (".dll", ".so", ".dylib")), DynamicCompletionRule(("open",), frozenset({1}), DynamicCompletionKind.PATH), - DynamicCompletionRule( - ("source",), frozenset({1, 3}), DynamicCompletionKind.PATH, (".tcl",) - ), + DynamicCompletionRule(("source",), frozenset({1, 3}), DynamicCompletionKind.PATH, (".tcl",)), *( DynamicCompletionRule( ("file", subcommand), @@ -666,12 +609,7 @@ SUBCOMMAND_SNIPPET_ITEMS = { TCL_COMMAND_NAMES = tuple( - sorted( - {path[0] for path in SUBCOMMANDS_BY_PATH} - | {path[0] for path in OPTIONS_BY_PATH} - | set(TCL_COMMAND_SNIPPET_ITEMS) - | {rule.path[0] for rule in DYNAMIC_COMPLETION_RULES} - ) + sorted({path[0] for path in SUBCOMMANDS_BY_PATH} | {path[0] for path in OPTIONS_BY_PATH} | set(TCL_COMMAND_SNIPPET_ITEMS) | {rule.path[0] for rule in DYNAMIC_COMPLETION_RULES}) ) TCL_COMMAND_ITEMS = tuple( @@ -688,9 +626,7 @@ TCL_COMMAND_ITEMS = tuple( ) -def line_prefix_at_position( - source_lines: Sequence[str], position: Position -) -> str | None: +def line_prefix_at_position(source_lines: Sequence[str], position: Position) -> str | None: """Return the current line before an LSP UTF-16 position.""" if position.line < 0 or position.line >= len(source_lines): @@ -703,9 +639,7 @@ def line_prefix_at_position( return line[:codepoint_offset] -def tcl_argument_completion( - source_lines: Sequence[str], position: Position -) -> TclArgumentCompletion | None: +def tcl_argument_completion(source_lines: Sequence[str], position: Position) -> TclArgumentCompletion | None: """Describe static and dynamic argument completion at ``position``. ``None`` means that the cursor is not at a command-specific completion @@ -771,7 +705,7 @@ def tcl_argument_completion( active_prefix, ) if option_completion is not None: - if active_prefix.startswith("-"): + if active_prefix.startswith("-") or (path == ("unset",) and active_index == 1 and not active_prefix): return option_completion return _merge_dynamic_completion( (*argument_items, *option_completion.items), @@ -780,9 +714,7 @@ def tcl_argument_completion( ) if argument_items: - return _merge_dynamic_completion( - argument_items, dynamic_completion, active_prefix - ) + return _merge_dynamic_completion(argument_items, dynamic_completion, active_prefix) return dynamic_completion @@ -827,9 +759,7 @@ def _option_completion( if active_prefix and not active_prefix.startswith("-"): return None - remaining_options = tuple( - option.label for option in options if option.label not in used_options - ) + remaining_options = tuple(option.label for option in options if option.label not in used_options) return TclArgumentCompletion( items=_completion_items( remaining_options, @@ -840,16 +770,9 @@ def _option_completion( ) -def _dynamic_completion( - words: Sequence[str], active_index: int, active_prefix: str -) -> TclArgumentCompletion | None: - for rule in sorted( - DYNAMIC_COMPLETION_RULES, key=lambda item: len(item.path), reverse=True - ): - if ( - active_index in rule.argument_indices - and tuple(words[: len(rule.path)]) == rule.path - ): +def _dynamic_completion(words: Sequence[str], active_index: int, active_prefix: str) -> TclArgumentCompletion | None: + for rule in sorted(DYNAMIC_COMPLETION_RULES, key=lambda item: len(item.path), reverse=True): + if active_index in rule.argument_indices and tuple(words[: len(rule.path)]) == rule.path: return TclArgumentCompletion( dynamic_kind=rule.kind, active_prefix=active_prefix, @@ -873,9 +796,7 @@ def _merge_dynamic_completion( ) -def _completion_items( - labels: Sequence[str], kind: CompletionItemKind, detail: str -) -> tuple[CompletionItem, ...]: +def _completion_items(labels: Sequence[str], kind: CompletionItemKind, detail: str) -> tuple[CompletionItem, ...]: return tuple( CompletionItem( label=label, @@ -913,9 +834,7 @@ def path_completion_items( except (OSError, ValueError): return () - allowed_extensions = { - extension.casefold() for extension in completion.path_extensions - } + allowed_extensions = {extension.casefold() for extension in completion.path_extensions} replace_start = max( 0, position.character - len(raw_prefix.encode("utf-16-le")) // 2, @@ -933,28 +852,17 @@ def path_completion_items( is_directory = entry.is_dir() except OSError: continue - if ( - not is_directory - and allowed_extensions - and entry.suffix.casefold() not in allowed_extensions - ): + if not is_directory and allowed_extensions and entry.suffix.casefold() not in allowed_extensions: continue - escaped_name = "".join( - f"\\{character}" if character.isspace() else character - for character in entry.name - ) + escaped_name = "".join(f"\\{character}" if character.isspace() else character for character in entry.name) new_text = f"{normalized_directory}{escaped_name}" if is_directory: new_text += "/" items.append( CompletionItem( label=new_text, - kind=( - CompletionItemKind.Folder - if is_directory - else CompletionItemKind.File - ), + kind=(CompletionItemKind.Folder if is_directory else CompletionItemKind.File), detail="Directory" if is_directory else "File", text_edit=TextEdit(range=replace_range, new_text=new_text), ) diff --git a/server/src/tools/tcloo_arguments.py b/server/src/tools/tcloo_arguments.py index d9c32e9..232d8ee 100644 --- a/server/src/tools/tcloo_arguments.py +++ b/server/src/tools/tcloo_arguments.py @@ -38,14 +38,14 @@ def method_parameters(parameters: str) -> list[MethodParameter]: return [] -def method_signature_help(source: str, position: lsp.Position) -> lsp.SignatureHelp | None: +def method_signature_help(source: str, position: lsp.Position, external_classes=None) -> lsp.SignatureHelp | None: lines = source.split("\n") if position.line >= len(lines): return None # AST columns are codepoints; LSP columns are UTF-16 code units. prefix = lines[position.line].encode("utf-16-le")[:position.character * 2].decode("utf-16-le", errors="ignore") cursor = (position.line, len(prefix)) - candidates = [call for call in resolved_method_calls(source) + candidates = [call for call in resolved_method_calls(source, external_classes) if _contains_cursor(call.command, lines, cursor)] if not candidates: return None diff --git a/server/src/tools/tcloo_completion.py b/server/src/tools/tcloo_completion.py index fb1f3f2..7caa1b8 100644 --- a/server/src/tools/tcloo_completion.py +++ b/server/src/tools/tcloo_completion.py @@ -1,4 +1,4 @@ -"""Conservative, document-local TclOO type inference without executing Tcl.""" +"""Static TclOO inference using local and indexed classes, without executing Tcl.""" from collections.abc import Sequence from dataclasses import dataclass, field @@ -17,6 +17,9 @@ class ClassInfo: methods: dict[str, tuple[str, Script | None]] = field(default_factory=dict) namespace: str = "" constructor: str = "" + definition: lsp.Location | None = None + method_definitions: dict[str, lsp.Location] = field(default_factory=dict) + constructor_definition: lsp.Location | None = None @dataclass @@ -25,6 +28,21 @@ class MethodCall: label: str parameters: str argument_offset: int = 1 + definition: lsp.Location | None = None + + +def name_location(node, uri, source): + """Locate the literal name, excluding braces/quotes, using UTF-16 columns.""" + if not uri or node.contents is None or node.contents_pos is None: + return None + line, column = node.contents_pos + lines = source.splitlines() + prefix = lines[line - 1][:column - 1] if line <= len(lines) else "" + start = len(prefix.encode("utf-16-le")) // 2 + end = start + len(node.contents.encode("utf-16-le")) // 2 + return lsp.Location(uri=uri, range=lsp.Range( + start=lsp.Position(line=line - 1, character=start), + end=lsp.Position(line=line - 1, character=end))) def parse_completion_source(source, pos=None): @@ -57,7 +75,7 @@ def _qualified(name, namespace): def tcloo_completions( - source_lines: Sequence[str], position: lsp.Position, + source_lines: Sequence[str], position: lsp.Position, external_classes=None, ) -> list[lsp.CompletionItem] | None: """Return receiver-specific methods, or None outside a known OO context.""" prefix = line_prefix_at_position(source_lines, position) @@ -77,7 +95,7 @@ def tcloo_completions( tree = parse_completion_source("\n".join(lines)) if tree is None: return None - classes, result, _ = _analyze(tree, typed, marker) + classes, result, _ = _analyze(tree, typed, marker, external_classes) if result is None: return None cls, internal = result @@ -99,11 +117,8 @@ def tcloo_completions( if name.startswith(typed) and (internal or not name.startswith("_") and not name[:1].isupper())] -def _analyze(tree, typed="", marker=""): - classes = {} +def _collect_classes(tree, classes, uri=None, source=""): contexts = [] - calls = [] - def collect(script, namespace=""): if script is None: return @@ -116,7 +131,9 @@ def _analyze(tree, typed="", marker=""): collect(_body(args[2]), _qualified(args[1].contents, namespace)) elif routine == "oo::class" and len(args) == 3 and args[0].contents == "create" and args[1].contents: name = _qualified(args[1].contents, namespace) - info = classes.setdefault(name, ClassInfo(namespace=namespace)) + info = ClassInfo(namespace=namespace) + info.definition = name_location(args[1], uri, source) + classes[name] = info body = _body(args[2]) if body is None: continue @@ -127,13 +144,31 @@ def _analyze(tree, typed="", marker=""): if method.routine.contents == "method" and len(ma) == 3 and ma[0].contents: method_body = _body(ma[2]) info.methods[ma[0].contents] = (ma[1].contents or "", method_body) + location = name_location(ma[0], uri, source) + if location is not None: + info.method_definitions[ma[0].contents] = location contexts.append((method_body, namespace, name)) elif method.routine.contents in {"constructor", "destructor"} and ma: if method.routine.contents == "constructor" and len(ma) == 2: info.constructor = ma[0].contents or "" + info.constructor_definition = name_location(method.routine, uri, source) contexts.append((_body(ma[-1]), namespace, name)) collect(tree) + return contexts + + +def indexed_classes(tree, uri=None, source=""): + classes = {} + _collect_classes(tree, classes, uri, source) + return classes + + +def _analyze(tree, typed="", marker="", external_classes=None, uri=None, source=""): + classes = dict(external_classes or {}) + calls = [] + + contexts = _collect_classes(tree, classes, uri, source) result = None def receiver(node, env, objects, namespace, owner, depth=0): @@ -180,13 +215,15 @@ def _analyze(tree, typed="", marker=""): cls = owner if name == "my" else receiver(cmd.routine, env, objects, namespace, owner) method_name = args[0].contents if args else None if cls in classes and method_name in classes[cls].methods: - calls.append(MethodCall(cmd, f"{cls} {method_name}", classes[cls].methods[method_name][0])) + calls.append(MethodCall(cmd, f"{cls} {method_name}", classes[cls].methods[method_name][0], + definition=classes[cls].method_definitions.get(method_name))) elif name and _qualified(name, namespace) in classes and method_name in {"new", "create"}: cls = _qualified(name, namespace) parameters = classes[cls].constructor if method_name == "create": parameters = "objectName " + parameters - calls.append(MethodCall(cmd, f"{cls} {method_name}", parameters)) + calls.append(MethodCall(cmd, f"{cls} {method_name}", parameters, + definition=classes[cls].constructor_definition or classes[cls].definition)) if marker and args and args[0].contents == typed + marker: cls = owner if name == "my" else receiver(cmd.routine, env, objects, namespace, owner) if cls in classes: @@ -221,6 +258,6 @@ def _analyze(tree, typed="", marker=""): return classes, result, calls -def resolved_method_calls(source): +def resolved_method_calls(source, external_classes=None): tree = parse_completion_source(source) - return _analyze(tree)[2] if tree is not None else [] + return _analyze(tree, external_classes=external_classes)[2] if tree is not None else [] diff --git a/server/src/tools/tcloo_navigation.py b/server/src/tools/tcloo_navigation.py new file mode 100644 index 0000000..69b8bcb --- /dev/null +++ b/server/src/tools/tcloo_navigation.py @@ -0,0 +1,35 @@ +"""Definition targets for literal TclOO classes and resolved method calls.""" + +from tools.tcloo_completion import _analyze, name_location, parse_completion_source +from tools.tcloo_symbols import class_symbols + + +def tcloo_definition(source, uri, position, external_classes=None): + tree = parse_completion_source(source) + if tree is None: + return None + classes, _, calls = _analyze(tree, external_classes=external_classes, uri=uri, source=source) + + def contains(location): + if location is None: + return False + start, end = location.range.start, location.range.end + return (start.line, start.character) <= (position.line, position.character) < (end.line, end.character) + + targets = {} + declarations, references = class_symbols(tree, classes, targets) + for node in references: + if contains(name_location(node, uri, source)): + return classes[targets[node.pos]].definition + for name, node in declarations.items(): + if contains(name_location(node, uri, source)): + return classes[name].definition + for call in calls: + if call.command.args and contains(name_location(call.command.args[0], uri, source)): + return call.definition + # F12 on a declaration itself should stay on that declaration. + for info in classes.values(): + for location in [*info.method_definitions.values(), info.constructor_definition]: + if location is not None and location.uri == uri and contains(location): + return location + return None diff --git a/server/src/tools/tcloo_symbols.py b/server/src/tools/tcloo_symbols.py index 4a3638b..d7862b5 100644 --- a/server/src/tools/tcloo_symbols.py +++ b/server/src/tools/tcloo_symbols.py @@ -6,7 +6,7 @@ from tclint.syntax_tree import Command from tools.tcloo_completion import _body, _qualified -def class_symbols(tree): +def class_symbols(tree, external_classes=None, reference_targets=None): """Return qualified class declarations and statically resolved name nodes.""" declarations = {} commands = [] @@ -34,13 +34,17 @@ def class_symbols(tree): walk(child, namespace, in_class) walk(tree) + known_classes = set(external_classes or ()) | declarations.keys() references = [] for command, namespace in commands: name = command.routine.contents - if name and any(candidate in declarations for candidate in ( + target = next((candidate for candidate in ( _qualified(name, namespace), _qualified(name, ""), - )): + ) if candidate in known_classes), None) if name else None + if target: references.append(command.routine) + if reference_targets is not None: + reference_targets[command.routine.pos] = target return declarations, references diff --git a/server/tests/python_tests/test_completion_context.py b/server/tests/python_tests/test_completion_context.py index 0e2accf..a58b5d9 100644 --- a/server/tests/python_tests/test_completion_context.py +++ b/server/tests/python_tests/test_completion_context.py @@ -103,6 +103,26 @@ def _argument_completion_labels(source: str) -> set[str] | None: return {item.label for item in completion.items} +def test_unset_space_shows_options_then_variables(tmp_path, monkeypatch): + server, document, _ = _completion_server(tmp_path, monkeypatch) + document = server.workspace.get_text_document(document.uri) + for version, tail in enumerate(["unset ", "unset -", "unset -nocomplain ", "unset -- ", "unset global"], start=2): + source = "set globalValue 1\n" + tail + document._source = source + document.version = version + items = _complete(document, lsp.Position(line=1, character=len(tail))) + labels = {item.label for item in items} + if tail in {"unset ", "unset -"}: + assert labels == {"-nocomplain", "--"} + else: + assert "globalValue" in labels + assert "-nocomplain" not in labels + if tail == "unset -nocomplain ": + assert "--" in labels + else: + assert "--" not in labels + + def test_array_keys_complete_in_set_and_substitution(tmp_path: Path, monkeypatch): server, _, _ = _completion_server(tmp_path, monkeypatch) workspace = _document( diff --git a/server/tests/python_tests/test_psc_classes.py b/server/tests/python_tests/test_psc_classes.py new file mode 100644 index 0000000..f9a2690 --- /dev/null +++ b/server/tests/python_tests/test_psc_classes.py @@ -0,0 +1,131 @@ +from pathlib import Path + +import lsprotocol.types as lsp +from pygls.workspace import Workspace +from pygls.workspace.text_document import TextDocument + +import lsp_server +from lsp_tclserver import TclLanguageServer +from tools.file_sourcing import psc_script_files +from tools.tcloo_completion import tcloo_completions +from tools.semantic_tokens import TOKEN_TYPE_INDEX + + +CLASS = '''oo::class create MCS { + method initOrg {dx dy dz} {return [self]} + method toStr {{precision 7}} {} +} +proc helper {value} {} +''' + + +def setup_project(tmp_path, monkeypatch): + root = tmp_path / "project" + root.mkdir() + library = tmp_path / "external library" + library.mkdir() + script = library / "geometry.tcl" + script.write_text(CLASS, encoding="utf-8") + psc = root / "post.psc" + psc.write_text(''' + + ''', encoding="utf-8") + server = TclLanguageServer(name="psc-test", version="1") + server.protocol._workspace = Workspace(root_uri=root.as_uri(), sync_kind=lsp.TextDocumentSyncKind.Incremental, + workspace_folders=[], position_encoding=lsp.PositionEncodingKind.Utf16) + monkeypatch.setattr(lsp_server, "LSP_SERVER", server) + return server, root, psc, script + + +def caller(server, root, source): + uri = (root / "caller.tcl").as_uri() + server.clear_cache_for_uri(uri) + server.workspace.put_text_document(lsp.TextDocumentItem(uri=uri, language_id="tcl", version=1, text=source)) + return uri, lsp.Position(line=len(source.splitlines()) - 1, character=len(source.splitlines()[-1])) + + +def test_psc_external_class_available_in_all_language_features(tmp_path, monkeypatch): + server, root, _, script = setup_project(tmp_path, monkeypatch) + lsp_server._refresh_psc_index() + assert any(server.paths_equal(script, path) for path in server.class_indexes) + assert {"MCS", "helper"} <= {item.label for item in server.completion_items_snapshot()} + + uri, position = caller(server, root, "set mcs [MCS new]\n$mcs ") + result = lsp_server.on_completion(lsp.CompletionParams(text_document=lsp.TextDocumentIdentifier(uri=uri), position=position)) + assert {"initOrg", "toStr"} <= {item.label for item in result.items} + + uri, position = caller(server, root, "set mcs [MCS new]\n$mcs initOrg 1 ") + result = lsp_server.signature_help(lsp.SignatureHelpParams(text_document=lsp.TextDocumentIdentifier(uri=uri), position=position)) + assert result.signatures[0].label == "::MCS initOrg dx dy dz" + assert result.active_parameter == 1 + + uri, _ = caller(server, root, "set mcs [MCS new]\n$mcs initOrg 1 2 3") + monkeypatch.setattr(lsp_server, "_get_settings_by_document", lambda doc: {"inlayHint": True}) + hints = lsp_server.inlay_hints(lsp.InlayHintParams(text_document=lsp.TextDocumentIdentifier(uri=uri), range=lsp.Range( + start=lsp.Position(line=0, character=0), end=lsp.Position(line=2, character=0)))) + assert [hint.label[0].value for hint in hints] == ["dx:", "dy:", "dz:"] + tokens = lsp_server.semantic_tokens(lsp.SemanticTokensParams(text_document=lsp.TextDocumentIdentifier(uri=uri))).data + assert TOKEN_TYPE_INDEX["class"] in tokens[3::5] + + uri, position = caller(server, root, "set mcs [MC") + result = lsp_server.on_completion(lsp.CompletionParams(text_document=lsp.TextDocumentIdentifier(uri=uri), position=position)) + assert any(item.label == "MCS" and item.kind == lsp.CompletionItemKind.Class for item in result.items) + + +def test_psc_refresh_removes_unlinked_external_classes(tmp_path, monkeypatch): + server, root, psc, script = setup_project(tmp_path, monkeypatch) + server.refresh_psc_scripts([root]) + psc.write_text("", encoding="utf-8") + lsp_server.did_change_watched_files(lsp.DidChangeWatchedFilesParams(changes=[ + lsp.FileEvent(uri=psc.as_uri(), type=lsp.FileChangeType.Changed)])) + assert "::MCS" not in server.class_snapshot(root / "caller.tcl") + assert not any(server.paths_equal(script, path) for path in server.class_indexes) + assert "MCS" not in {item.label for item in server.completion_items_snapshot()} + + +def test_class_metadata_updates_and_local_override_does_not_mutate_index(tmp_path, monkeypatch): + server, root, _, script = setup_project(tmp_path, monkeypatch) + server.refresh_psc_scripts([root]) + classes = server.class_snapshot(root / "caller.tcl") + source = "oo::class create MCS {method local {} {}}\nset mcs [MCS new]\n$mcs " + items = tcloo_completions(source.splitlines(), lsp.Position(line=2, character=5), classes) + assert {item.label for item in items} == {"local", "destroy"} + assert "local" not in classes["::MCS"].methods + document = TextDocument(uri=script.as_uri(), source="oo::class create MCS {method changed {} {}}", version=2) + assert server.update_poco_completion_for_file(document) + assert set(server.class_snapshot(root / "caller.tcl")["::MCS"].methods) == {"changed"} + server.remove_file_state(script.as_uri()) + assert "::MCS" not in server.class_snapshot(root / "caller.tcl") + + +def test_psc_load_order_missing_files_and_xml_namespace(tmp_path, monkeypatch): + server, root, psc, script = setup_project(tmp_path, monkeypatch) + override = root / "override.tcl" + override.write_text("oo::class create MCS {method override {} {}}", encoding="utf-8") + psc.write_text(f''' + + + ''', encoding="utf-8") + assert psc_script_files(psc) == [script, override, root / "missing.tcl"] + messages = [] + server.refresh_psc_scripts([root], messages.append) + assert set(server.class_snapshot(root / "caller.tcl")["::MCS"].methods) == {"override"} + assert any("missing.tcl" in message for message in messages) + + +def test_psc_refresh_preserves_unsaved_open_library(tmp_path, monkeypatch): + server, root, _, script = setup_project(tmp_path, monkeypatch) + server.workspace.put_text_document(lsp.TextDocumentItem(uri=script.as_uri(), language_id="tcl", version=3, + text="oo::class create MCS {method unsaved {} {}}")) + server.refresh_psc_scripts([root]) + assert set(server.class_snapshot(root / "caller.tcl")["::MCS"].methods) == {"unsaved"} + + +def test_psc_environment_folder_and_legacy_encoding(tmp_path, monkeypatch): + server, root, psc, script = setup_project(tmp_path, monkeypatch) + monkeypatch.setenv("UGII_CAM_SHOP_DOC_DIR", str(script.parent)) + psc.write_text(''' + ''', encoding="utf-8") + script.write_bytes(("# Γ„ltere Bibliothek\n" + CLASS).encode("cp1252")) + server.refresh_psc_scripts([root]) + assert "::MCS" in server.class_snapshot(root / "caller.tcl") diff --git a/server/tests/python_tests/test_tcloo_highlighting.py b/server/tests/python_tests/test_tcloo_highlighting.py new file mode 100644 index 0000000..c9a9752 --- /dev/null +++ b/server/tests/python_tests/test_tcloo_highlighting.py @@ -0,0 +1,56 @@ +import lsprotocol.types as lsp + +from tools.parser import CustomParser +from tools.semantic_tokens import _Highlighter, TOKEN_TYPE_INDEX, TokenModifier + + +def test_methods_use_proc_colors_without_coloring_plain_arguments(): + source = '''oo::class create MCS { + method initOrg {x y z} {return [self]} + method reset {} {my initOrg 0 0 0} +} +set obj [MCS new] +$obj initOrg 1 2 3 +puts initOrg +# initOrg +''' + tree = CustomParser().parse(source) + highlighter = _Highlighter([], {}) + highlighter.highlight_classes(tree) + highlighter.highlight_methods(tree, source, "file:///test.tcl") + tree.accept(highlighter, recurse=True) + line = column = 0 + tokens = [] + for token in highlighter.tokens(): + column = column + token.offset if token.line == 0 else token.offset + line += token.line + text = source.splitlines()[line][column:column + token.length] + tokens.append((line, column, text, token.tok_type, token.tok_modifiers)) + methods = [token for token in tokens if token[2] in {"initOrg", "reset"}] + assert [token[2] for token in methods] == ["initOrg", "reset", "initOrg", "initOrg"] + assert all(token[3] == "function" for token in methods) + assert TokenModifier.declaration in methods[0][4] + assert TokenModifier.declaration in methods[1][4] + assert all(token[3] == "class" for token in tokens if token[2] == "MCS") + assert len({token[:2] for token in tokens}) == len(tokens) + + +def test_psc_method_calls_are_function_tokens(tmp_path, monkeypatch): + import lsp_server + from test_psc_classes import setup_project, caller + + server, root, _, _ = setup_project(tmp_path, monkeypatch) + server.refresh_psc_scripts([root]) + source = "set obj [MCS new]\n$obj initOrg 1 2 3" + uri, _ = caller(server, root, source) + data = lsp_server.semantic_tokens(lsp.SemanticTokensParams( + text_document=lsp.TextDocumentIdentifier(uri=uri))).data + line = column = 0 + tokens = {} + for index in range(0, len(data), 5): + delta, offset, length, kind, _ = data[index:index + 5] + column = column + offset if delta == 0 else offset + line += delta + tokens[(line, source.splitlines()[line][column:column + length])] = kind + assert tokens[(1, "initOrg")] == TOKEN_TYPE_INDEX["function"] + assert tokens[(0, "MCS")] == TOKEN_TYPE_INDEX["class"] diff --git a/server/tests/python_tests/test_tcloo_navigation.py b/server/tests/python_tests/test_tcloo_navigation.py new file mode 100644 index 0000000..bed03a7 --- /dev/null +++ b/server/tests/python_tests/test_tcloo_navigation.py @@ -0,0 +1,94 @@ +import lsprotocol.types as lsp +import pytest +from pygls import uris + +from tools.tcloo_navigation import tcloo_definition + + +CLASS = '''oo::class create MCS { + constructor {value} {} + method initOrg {dx dy dz} {return [self]} + method toStr {} {my initOrg 1 2 3} +} +''' + + +def locate(source, classes=None): + prefix, suffix = source.split("|") + return tcloo_definition(prefix + suffix, "file:///caller.tcl", lsp.Position( + line=prefix.count("\n"), + character=len(prefix.rsplit("\n", 1)[-1].encode("utf-16-le")) // 2), classes) + + +def target_text(location, source): + assert location is not None + span = location.range + line = source.splitlines()[span.start.line].encode("utf-16-le") + return line[span.start.character * 2:span.end.character * 2].decode("utf-16-le") + + +@pytest.mark.parametrize("code, expected", [ + ("set mcs [M|CS new 0]", "MCS"), + ("set mcs [::M|CS new 0]", "MCS"), + ("set mcs [MCS n|ew 0]", "constructor"), + ("MCS cr|eate instance 0", "constructor"), + ("set mcs [MCS new 0]\n$mcs init|Org 1 2 3", "initOrg"), + ("MCS create instance 0\ninstance to|Str", "toStr"), + ("set mcs [[MCS new 0] initOrg 1 2 3]\n$mcs to|Str", "toStr"), + ("set mcs [MCS new 0]\nputs [$mcs init|Org", "initOrg"), + ("puts πŸ˜€; set mcs [M|CS new 0]", "MCS"), +]) +def test_local_class_method_and_constructor_targets(code, expected): + source = CLASS + code + target = locate(source) + assert target.uri == "file:///caller.tcl" + assert target_text(target, source.replace("|", "")) == expected + + +def test_my_and_method_declaration(): + for source in [CLASS.replace("my initOrg", "my init|Org"), CLASS.replace("method initOrg", "method init|Org")]: + assert target_text(locate(source), CLASS) == "initOrg" + + +@pytest.mark.parametrize("code", [ + "set mcs [MCS new 0]\nset mcs text\n$mcs init|Org 1 2 3", + "$unknown init|Org 1 2 3", + "puts {M|CS}", + "# M|CS", + "set mcs [MCS new 0]\n$mcs initOrg to|Str 2 3", +]) +def test_no_guessing_for_unknown_receivers_or_plain_text(code): + assert locate(CLASS + code) is None + + +def test_same_method_name_resolves_to_correct_class(): + source = CLASS + "oo::class create Other {method initOrg {} {}}\nset obj [Other new]\n$obj init|Org" + target = locate(source) + assert target.range.start.line == 5 + + +def test_namespaced_class_and_utf16_definition(): + source = 'namespace eval geo {\nputs πŸ˜€; ' + CLASS + '\nset obj [MCS new 0]\n$obj init|Org 1 2 3\n}' + assert target_text(locate(source), source.replace("|", "")) == "initOrg" + source = 'puts πŸ˜€; ' + CLASS + '\nset obj [M|CS new 0]' + target = locate(source) + assert target_text(target, source.replace("|", "")) == "MCS" + + +def test_psc_definition_navigation_uses_library_uri(tmp_path, monkeypatch): + import lsp_server + from test_psc_classes import setup_project, caller, CLASS as LIBRARY_SOURCE + + server, root, _, script = setup_project(tmp_path, monkeypatch) + server.refresh_psc_scripts([root]) + for word, source in [ + ("MCS", "set obj [MCS new]"), + ("initOrg", "set obj [MCS new]\n$obj initOrg 1 2 3"), + ]: + uri, _ = caller(server, root, source) + lines = source.splitlines() + position = lsp.Position(line=len(lines) - 1, character=lines[-1].index(word) + 1) + result = lsp_server.goto_definition(lsp.DefinitionParams(text_document=lsp.TextDocumentIdentifier(uri=uri), position=position)) + assert result is not None and len(result) == 1 + assert server.paths_equal(script, uris.to_fs_path(result[0].uri)) + assert target_text(result[0], LIBRARY_SOURCE) == word diff --git a/test/test.tcl b/test/test.tcl index bfba383..c4020e7 100644 --- a/test/test.tcl +++ b/test/test.tcl @@ -403,3 +403,7 @@ oo::class create Point3D { return [self] } } + +set v1 [MCS new] + +$v1 initArray From 547da644ce2806888ad33b7bf98e8981ac542fde Mon Sep 17 00:00:00 2001 From: Christoph Brandau Date: Mon, 21 Sep 2026 20:51:02 +0200 Subject: [PATCH 2/3] feat(cdlEventHandler): detect TOGGLE Off and emit *_defined globals Record parameters marked with "TOGGLE Off" by adding an optional toggleOffParameterNames field and including an extra _defined global for each such parameter in createCdlEventHandlerSnippet. To support this, the parser was changed from a brace-delta approach to a token-based scanner so nesting and the association between a PARAM and its TOGGLE can be tracked reliably. Added unit tests that verify detection, case-insensitivity, and ignoring TOGGLE occurrences inside comments/strings or other events. --- client/src/common/cdlEventHandler.ts | 62 ++++++++++++++-------------- test/cdlEventHandler.test.js | 51 +++++++++++++++++++++++ 2 files changed, 83 insertions(+), 30 deletions(-) create mode 100644 test/cdlEventHandler.test.js diff --git a/client/src/common/cdlEventHandler.ts b/client/src/common/cdlEventHandler.ts index b6282c9..7b750ed 100644 --- a/client/src/common/cdlEventHandler.ts +++ b/client/src/common/cdlEventHandler.ts @@ -1,6 +1,7 @@ export interface CdlEventHandler { eventName: string parameterNames: string[] + toggleOffParameterNames?: string[] } function structuralCode(line: string): string { @@ -33,18 +34,6 @@ function structuralCode(line: string): string { return result } -function braceDelta(line: string): number { - let delta = 0 - for (const character of structuralCode(line)) { - if (character === "{") { - delta += 1 - } else if (character === "}") { - delta -= 1 - } - } - return delta -} - export function cdlEventHandlerAtLine( source: string, declarationLine: number @@ -61,35 +50,44 @@ export function cdlEventHandlerAtLine( } const parameterNames: string[] = [] + const toggleOffParameterNames: string[] = [] + let currentParameter: string | undefined let eventOpened = false let depth = 0 - for (let lineNumber = declarationLine; lineNumber < lines.length; lineNumber++) { + eventLines: for (let lineNumber = declarationLine; lineNumber < lines.length; lineNumber++) { const line = lines[lineNumber] const code = structuralCode(line) - if (eventOpened && depth === 1) { - const parameterMatch = /^\s*PARAM\s+([^\s{]+)/.exec(code) - if (parameterMatch) { - parameterNames.push(parameterMatch[1]) - } - } - - const delta = braceDelta(line) - if (!eventOpened && delta > 0) { - eventOpened = true - } - if (eventOpened) { - depth += delta - if (depth <= 0) { - break + const tokens = code.match(/[{}]|[^\s{}]+/g) ?? [] + for (let index = 0; index < tokens.length; index++) { + const token = tokens[index] + if (token === "{") { + eventOpened = true + depth++ + } else if (token === "}" && eventOpened) { + depth-- + if (depth === 1) currentParameter = undefined + if (depth <= 0) break eventLines + } else if (depth === 1 && token === "PARAM") { + const name = tokens[index + 1] + if (name && name !== "{" && name !== "}") { + currentParameter = name + parameterNames.push(name) + index++ + } + } else if (depth === 2 && currentParameter && token === "TOGGLE") { + if (tokens[index + 1]?.toLowerCase() === "off") { + toggleOffParameterNames.push(currentParameter) + } } } } return { eventName: eventMatch[1], - parameterNames + parameterNames, + toggleOffParameterNames } } @@ -102,8 +100,12 @@ function momVariableName(parameterName: string): string { } export function createCdlEventHandlerSnippet(handler: CdlEventHandler): string { + const toggleOffParameters = new Set(handler.toggleOffParameterNames ?? []) const globals = [ - ...new Set(handler.parameterNames.map((parameter) => momVariableName(parameter))) + ...new Set(handler.parameterNames.flatMap((parameter) => { + const variable = momVariableName(parameter) + return toggleOffParameters.has(parameter) ? [variable, `${variable}_defined`] : [variable] + })) ] const lines = [`proc ${momEventName(handler.eventName)} {args} {`] diff --git a/test/cdlEventHandler.test.js b/test/cdlEventHandler.test.js new file mode 100644 index 0000000..6276870 --- /dev/null +++ b/test/cdlEventHandler.test.js @@ -0,0 +1,51 @@ +const assert = require("node:assert/strict") +const fs = require("node:fs") +const path = require("node:path") +const vm = require("node:vm") +const { test } = require("node:test") +const { transformSync } = require("esbuild") + +const source = fs.readFileSync(path.join(__dirname, "../client/src/common/cdlEventHandler.ts"), "utf8") +const compiled = transformSync(source, { loader: "ts", format: "cjs" }).code +const context = { module: { exports: {} } } +vm.runInNewContext(compiled, context) +const { cdlEventHandlerAtLine, createCdlEventHandlerSnippet } = context.module.exports + +test("TOGGLE Off adds the defined globals to the event handler", () => { + const cdl = `EVENT GDM_header +{ + PARAM product_status { + TYPE o + OPTIONS "Serie", "Prototyp" + } + PARAM stm_param_mpf_name + { + TYPE s + TOGGLE Off + } + PARAM stm_param_wks_path { + TYPE s + TOGGLE Off + } +}` + const snippet = createCdlEventHandlerSnippet(cdlEventHandlerAtLine(cdl, 0)) + assert.match(snippet, /global mom_stm_param_mpf_name_defined/) + assert.match(snippet, /global mom_stm_param_wks_path_defined/) + assert.match(snippet, /global mom_product_status\n/) + assert.doesNotMatch(snippet, /mom_product_status_defined/) +}) + +test("toggle detection ignores comments, strings, other events, and TOGGLE On", () => { + const cdl = `EVENT first { + PARAM plain { TYPE s UI_LABEL "TOGGLE Off { ignored }" } + PARAM enabled { TOGGLE On } + PARAM commented { TYPE s # TOGGLE Off + } + PARAM mom_disabled { TOGGLE off } + } + EVENT second { PARAM other { TOGGLE Off } }` + const snippet = createCdlEventHandlerSnippet(cdlEventHandlerAtLine(cdl, 0)) + assert.match(snippet, /global mom_disabled_defined/) + assert.equal((snippet.match(/_defined/g) ?? []).length, 1) + assert.doesNotMatch(snippet, /mom_mom_|mom_other/) +}) From 84821d28525e2de23ae3d6ba1628e5adb7f5da8a Mon Sep 17 00:00:00 2001 From: Christoph Brandau Date: Mon, 21 Sep 2026 20:52:53 +0200 Subject: [PATCH 3/3] feat(cdl): allow INVALID in CATEGORY pattern Accept "INVALID" as a valid token in the CATEGORY grammar rule (both the initial and repeated entries). Also compacted several JSON objects (pattern includes and "captures" entries) in syntaxes/cdl.tmLanguage.json; these formatting changes are non-functional. --- syntaxes/cdl.tmLanguage.json | 66 ++++++++---------------------------- 1 file changed, 14 insertions(+), 52 deletions(-) diff --git a/syntaxes/cdl.tmLanguage.json b/syntaxes/cdl.tmLanguage.json index d2052f6..7cd2f44 100644 --- a/syntaxes/cdl.tmLanguage.json +++ b/syntaxes/cdl.tmLanguage.json @@ -2,27 +2,13 @@ "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json", "name": "CDL Support", "patterns": [ - { - "include": "#comment" - }, - { - "include": "#function" - }, - { - "include": "#variables" - }, - { - "include": "#types" - }, - { - "include": "#keywords" - }, - { - "include": "#numbers" - }, - { - "include": "#strings" - } + { "include": "#comment" }, + { "include": "#function" }, + { "include": "#variables" }, + { "include": "#types" }, + { "include": "#keywords" }, + { "include": "#numbers" }, + { "include": "#strings" } ], "repository": { "keywords": { @@ -70,11 +56,7 @@ { "name": "keyword.control.cdl", "match": "TYPE\\s+(o|g|i|d|b|s)\\b", - "captures": { - "1": { - "name": "storage.type.cs" - } - } + "captures": { "1": { "name": "storage.type.cs" } } } ] }, @@ -83,38 +65,22 @@ { "name": "keyword.control.cdl", "match": "\\b(PARAM|EVENT)\\s+([a-zA-Z_]\\w*)\\b", - "captures": { - "2": { - "name": "variable.other.cdl" - } - } + "captures": { "2": { "name": "variable.other.cdl" } } }, { "name": "keyword.control.cdl", "match": "\\bMACHINE\\s+([a-zA-Z_]\\w*)\\b", - "captures": { - "1": { - "name": "variable.other.cdl" - } - } + "captures": { "1": { "name": "variable.other.cdl" } } }, { "name": "keyword.control.cdl", - "match": "\\bCATEGORY\\s+((MILL|LATHE|DRILL)(\\s+(MILL|LATHE|DRILL))*)\\b", - "captures": { - "1": { - "name": "variable.language.cdl" - } - } + "match": "\\bCATEGORY\\s+((MILL|LATHE|DRILL|INVALID)(\\s+(MILL|LATHE|DRILL|INVALID))*)\\b", + "captures": { "1": { "name": "variable.language.cdl" } } }, { "name": "keyword.control.cdl", "match": "\\bTOGGLE\\s+(OFF|ON|off|on)\\b", - "captures": { - "1": { - "name": "variable.other.constant" - } - } + "captures": { "1": { "name": "variable.other.constant" } } } ] }, @@ -123,11 +89,7 @@ { "name": "storage.type.function.cdl", "match": "\\bEVENT\\s+([a-zA-Z_]\\w*)\\b", - "captures": { - "1": { - "name": "entity.name.function" - } - } + "captures": { "1": { "name": "entity.name.function" } } } ] },