Merge pull request 'Check Array Paramter' (#38) from #150 into main

This adds tooling to statically extract Tcl variable names from syntax
trees without evaluating substitutions, enabling better completions
for array elements and plain variables. The new helpers are wired
into the completion and navigation flows and are supported by tests
covering array keys and substitutions.

- Introduce variable_names.py with variable_name() and array_key_parts()
- Wire static name extraction into completion and symbol indexing
- Add tests for array key completion with substitutions

.vscode/launch.json

@@ -17,6 +17,19 @@
             ],
             "cwd": "${env:TEMP}/nx-post-support-vscode-debug",
             "outFiles": ["${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js"],
+            "linux": {
+                "args": [
+                    "--extensionDevelopmentPath=${workspaceFolder}",
+                    "${workspaceFolder}",
+                    "${workspaceFolder}/test/test.tcl"
+                ],
+                "cwd": "${workspaceFolder}",
+                "outFiles": ["${workspaceFolder}/dist/**/*.js"],
+                "resolveSourceMapLocations": [
+                    "${workspaceFolder}/dist/**/*.js",
+                    "!**/node_modules/**"
+                ]
+            },
             "sourceMaps": true,
             "resolveSourceMapLocations": [
                 "${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js",
@@ -50,6 +63,19 @@
             ],
             "cwd": "${env:TEMP}/nx-post-support-vscode-debug",
             "outFiles": ["${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js"],
+            "linux": {
+                "args": [
+                    "--extensionDevelopmentPath=${workspaceFolder}",
+                    "${workspaceFolder}",
+                    "${workspaceFolder}/test/test.tcl"
+                ],
+                "cwd": "${workspaceFolder}",
+                "outFiles": ["${workspaceFolder}/dist/**/*.js"],
+                "resolveSourceMapLocations": [
+                    "${workspaceFolder}/dist/**/*.js",
+                    "!**/node_modules/**"
+                ]
+            },
             "sourceMaps": true,
             "resolveSourceMapLocations": [
                 "${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js",

.vscode/tasks.json

@@ -15,6 +15,13 @@
                 "${workspaceFolder}",
                 "${env:TEMP}\\nx-post-support-vscode-debug"
             ],
+            "linux": {
+                "command": "npm",
+                "args": ["run", "compile:debug"],
+                "options": {
+                    "cwd": "${workspaceFolder}"
+                }
+            },
             "problemMatcher": [],
             "presentation": {
                 "reveal": "always",

CHANGELOG.md

@@ -3,6 +3,9 @@
 - Add incoming and outgoing call hierarchy for custom TCL procedures and MOM event handlers
 - Add document highlights for procedure and variable occurrences
 - Make completion context-aware and prioritize local, current-file, workspace, and built-in symbols
+- Add command-aware completion for Tcl subcommands, fixed arguments, and valid options
+- Add semantic argument completion for variables, procedures, namespaces, and local file paths
+- Add placeholder-based snippets for common Tcl structures and `dict for`
 - Integrate the NX Tcl Remote Debugger directly into NX Postprocessor Support
 - Add `nx-tcl` attach configurations and breakpoint support for TCL and DEF files
 - Support breakpoints, stepping, stack frames, variables, watches, evaluation, logpoints, hit conditions, and Tcl error stops

README.md

@@ -12,7 +12,8 @@ A comprehensive VS Code extension providing language support and remote debuggin
 - **Signature Help** - Shows parameters and documentation for custom and NX procedures
 - **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 or commands based on cursor context
+- **Context-aware Completion** - Prioritizes local symbols and suggests variables, procedures, namespaces, paths, Tcl subcommands, valid argument values, and options based on cursor context
+- **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
 
 ## Supported File Types
@@ -101,7 +102,8 @@ Simply open any supported file type and enjoy:
 - Signature help while entering procedure arguments
 - Incoming and outgoing call hierarchy for custom procedures and MOM event handlers
 - Document-wide highlights for procedure and variable occurrences
-- Context-aware completion with local symbols ranked before workspace and built-in symbols
+- Context-aware completion with local symbols ranked before workspace and built-in symbols, plus semantic arguments, local paths, Tcl subcommands, and options such as `string compare -nocase`
+- Placeholder-based snippets for common Tcl control structures and procedures
 - Remote NX Tcl debugging with breakpoints and full stepping
 
 ## Contributing

client/src/common/cdlEventHandler.ts

@@ -105,7 +105,7 @@ export function createCdlEventHandlerSnippet(handler: CdlEventHandler): string {
     const globals = [
         ...new Set(handler.parameterNames.map((parameter) => momVariableName(parameter)))
     ]
-    const lines = [`proc ${momEventName(handler.eventName)} { } {`]
+    const lines = [`proc ${momEventName(handler.eventName)} {args} {`]
 
     if (globals.length > 0) {
         lines.push(...globals.map((variable) => `    global ${variable}`), "")

package.json

@@ -2,7 +2,7 @@
   "name": "nx-post-support",
   "displayName": "NX Postprocessor Support",
   "description": "VS Code extension for NX CAM postprocessor development with language support and remote Tcl debugging for CDL, TCL, and DEF files",
-  "version": "2026.8.300",
+  "version": "2026.9.220",
   "publisher": "Christoph",
   "icon": "images/nx-1.png",
   "activationEvents": [

server/src/lsp_server.py

@@ -38,13 +38,19 @@ update_sys_path(
 # Imports needed for the language server goes below this.
 # **********************************************************
 # pylint: disable=wrong-import-position,import-error
-import lsp_jsonrpc as jsonrpc
 import lsprotocol.types as lsp
-from common.load_data import standard_items
-from lsp_tclserver import TclLanguageServer
 from pygls import uris
 from pygls.workspace.text_document import TextDocument
-from tools.completion_items import completion_context, ranked_completion_items
+
+import lsp_jsonrpc as jsonrpc
+from common.load_data import standard_items
+from lsp_tclserver import TclLanguageServer
+from tools.completion_items import (
+    CompletionContext,
+    array_element_completions,
+    completion_context,
+    ranked_completion_items,
+)
 from tools.folding_ranges import build_folding_ranges
 from tools.inlay_hint import (
     InlayHintGenerator,
@@ -69,6 +75,13 @@ from tools.semantic_tokens import (
     _Highlighter,
 )
 from tools.signature_help import build_signature_help
+from tools.tcl_command_completion import (
+    TCL_COMMAND_ITEMS,
+    TCL_COMMAND_NAMES,
+    DynamicCompletionKind,
+    path_completion_items,
+    tcl_argument_completion,
+)
 
 WORKSPACE_SETTINGS = {}
 GLOBAL_SETTINGS = {}
@@ -82,10 +95,19 @@ LSP_SERVER = TclLanguageServer(
 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
+]
+_STATIC_TCL_LABELS = {item.label for item in standard_items.tcl_keyword_list}
 STATIC_COMPLETION_ITEMS = tuple(
-    standard_items.tcl_keyword_list
+    _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
 )
@@ -250,16 +272,73 @@ def document_diagnostic(params: lsp.DocumentDiagnosticParams):
 
 @LSP_SERVER.feature(
     lsp.TEXT_DOCUMENT_COMPLETION,
-    lsp.CompletionOptions(trigger_characters=["$"]),
+    lsp.CompletionOptions(trigger_characters=["$", " ", "-", "(", ","]),
 )
 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)
+    array_items = array_element_completions(
+        source_lines, position, LSP_SERVER.navigation_snapshot().values(),
+        str(pathlib.Path(uris.to_fs_path(doc.uri))),
+    )
+    if array_items is not None:
+        return lsp.CompletionList(is_incomplete=False, items=array_items)
+    context = completion_context(source_lines, position)
+
+    # Variable completion wins inside command arguments. Otherwise prefer the
+    # narrow command grammar when the cursor is at a known subcommand/option.
+    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
+        ):
+            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
+        ):
+            dynamic_items: tuple[lsp.CompletionItem, ...] = ()
+            if doc.uri.startswith("file:"):
+                document_path = pathlib.Path(uris.to_fs_path(doc.uri))
+                dynamic_items = path_completion_items(
+                    document_path.parent,
+                    argument_completion,
+                    position,
+                )
+            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,
+                CompletionContext.GENERAL,
+            )
+            return lsp.CompletionList(is_incomplete=False, items=items)
+
+    # Space and dash are registered only to open command-aware suggestions.
+    # Do not display the broad fallback list when such a trigger has no match.
+    if (
+        argument_completion is None
+        and params.context is not None
+        and params.context.trigger_kind
+        == lsp.CompletionTriggerKind.TriggerCharacter
+        and params.context.trigger_character in {" ", "-", "(", ","}
+    ):
+        return lsp.CompletionList(is_incomplete=False, items=[])
+
     tree = LSP_SERVER.get_tree(doc)
     globals_set, procs_locals, proc_ranges = LSP_SERVER.variable_index_for_document(
         doc, tree
     )
 
-    position = params.position
     local_names: set[str] = set()
     for proc_range in proc_ranges:
         end_line = proc_range.end_line or proc_range.start_line
@@ -301,8 +380,70 @@ def on_completion(params: lsp.CompletionParams) -> lsp.CompletionList:
         priority = 100 if LSP_SERVER.paths_equal(item_path, filepath) else 200
         candidates.extend((priority, item) for item in items_by_file[item_path])
 
+    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
+            )
+            items = ranked_completion_items(
+                variable_candidates,
+                CompletionContext.VARIABLE,
+            )
+            return lsp.CompletionList(is_incomplete=False, items=items)
+
+        if argument_completion.dynamic_kind == DynamicCompletionKind.PROCEDURE:
+            procedure_kinds = {
+                lsp.CompletionItemKind.Constructor,
+                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
+            )
+            items = ranked_completion_items(
+                [*static_candidates, *procedure_candidates],
+                CompletionContext.GENERAL,
+            )
+            return lsp.CompletionList(is_incomplete=False, items=items)
+
+        if argument_completion.dynamic_kind == DynamicCompletionKind.NAMESPACE:
+            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
+                )
+                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",
+                            ),
+                        )
+                    )
+            items = ranked_completion_items(
+                namespace_candidates,
+                CompletionContext.GENERAL,
+            )
+            return lsp.CompletionList(is_incomplete=False, items=items)
+
     candidates.extend((300, item) for item in STATIC_COMPLETION_ITEMS)
-    context = completion_context(LSP_SERVER.get_lines(doc), position)
     items = ranked_completion_items(candidates, context)
     return lsp.CompletionList(is_incomplete=False, items=items)
 

server/src/tools/completion_items.py

@@ -6,9 +6,17 @@ from collections.abc import Iterable, Sequence
 from enum import Enum
 
 import lsprotocol.types as lsp
-from common.load_data import standard_items
 from tclint.syntax_tree import BareWord, Command, List, Visitor
 
+from common.load_data import standard_items
+from tools.navigation import FileSymbolIndex
+from tools.variable_names import variable_name
+from tools.tcl_command_completion import (
+    DynamicCompletionKind,
+    line_prefix_at_position,
+    tcl_argument_completion,
+)
+
 BUILTIN_VAR_LABELS = {ci.label for ci in standard_items.nx_variables}
 BUILTIN_PROC_LABELS = {ci.label for ci in standard_items.nx_procs}
 
@@ -29,33 +37,107 @@ COMMAND_KINDS = {
     lsp.CompletionItemKind.Method,
     lsp.CompletionItemKind.Constructor,
     lsp.CompletionItemKind.Keyword,
+    lsp.CompletionItemKind.Snippet,
 }
 
 _VARIABLE_PREFIX_RE = re.compile(r"(?<!\\)\$(?:\{)?[A-Za-z0-9_:]*$")
 _COMMAND_PREFIX_RE = re.compile(r"(?:^|[;\[\{])\s*[^\s;\[\]\{\}]*$")
+_ARRAY_PREFIX_RE = re.compile(
+    r"(?P<name>(?:::)?[A-Za-z_][A-Za-z0-9_:]*)\((?P<key>[^()\n]*)$"
+)
 
 
-def _codepoint_offset(line: str, utf16_offset: int) -> int:
-    """Translate an LSP UTF-16 character offset into a Python string offset."""
-    if utf16_offset <= 0:
-        return 0
-
-    units = 0
-    for offset, character in enumerate(line):
-        units += 2 if ord(character) > 0xFFFF else 1
-        if units >= utf16_offset:
-            return offset + 1
-    return len(line)
+def array_element_completions(
+    source_lines: Sequence[str],
+    position: lsp.Position,
+    indexes: Iterable[FileSymbolIndex],
+    current_path: str,
+) -> list[lsp.CompletionItem] | None:
+    """Complete literal array keys, replacing only the text inside parentheses."""
+    prefix = line_prefix_at_position(source_lines, position)
+    if prefix is None:
+        return None
+    match = _ARRAY_PREFIX_RE.search(prefix)
+    if match is None:
+        return None
+    before = prefix[:match.start()]
+    if not before.endswith("$"):
+        argument = tcl_argument_completion(source_lines, position)
+        if argument is None or argument.dynamic_kind != DynamicCompletionKind.VARIABLE:
+            return None
+    name, key_prefix = match.group("name", "key")
+    part_index = key_prefix.count(",")
+    key_prefix = key_prefix.rsplit(",", 1)[-1]
+    if any(char in key_prefix for char in "$[]{}\\"):
+        return None
+    indexes = list(indexes)
+    local_scope = None
+    for index in indexes:
+        if index.path != current_path:
+            continue
+        for occurrence in index.occurrences:
+            span = occurrence.declaration_range
+            if (
+                occurrence.identity.kind == "proc"
+                and occurrence.is_definition
+                and span is not None
+                and span.start.line <= position.line <= span.end.line
+            ):
+                local_scope = f"{index.path}::proc::{occurrence.identity.name}"
+    keys: dict[str, set[tuple[str | None, ...]]] = {}
+    for index in indexes:
+        for occurrence in index.occurrences:
+            parts = occurrence.array_parts
+            key = parts[part_index] if part_index < len(parts) else None
+            if (
+                key
+                and (
+                    occurrence.identity.scope is None
+                    or occurrence.identity.scope == local_scope
+                )
+                and key.startswith(key_prefix)
+                and not any(char in key for char in "$[]\\")
+                and occurrence.identity.name.removeprefix("::") == name.removeprefix("::")
+            ):
+                keys.setdefault(key, set()).add(occurrence.array_template_parts[part_index + 1:])
+    line = source_lines[position.line]
+    suffix = line[len(prefix):]
+    remaining = re.match(r"[^(),\s$\[\]{}]*", suffix).group()
+    has_close = suffix[len(remaining):].startswith((")", ","))
+    start = position.character - len(key_prefix.encode("utf-16-le")) // 2
+    end = position.character + len(remaining.encode("utf-16-le")) // 2
+    items = []
+    for key in sorted(keys):
+        new_text = key
+        # Fill missing index components only; keep an existing comma and suffix.
+        if not suffix[len(remaining):].startswith(","):
+            tails = sorted(keys[key], key=lambda tail: (len(tail), repr(tail)))
+            tail = tails[0]
+            if all(part is not None for part in tail) and any("$" in part for part in tail):
+                new_text = ",".join([key, *tail])
+        new_text += "" if has_close else ")"
+        items.append(lsp.CompletionItem(
+            label=key,
+            kind=lsp.CompletionItemKind.Field,
+            detail=f"{name}({key})",
+            insert_text_format=lsp.InsertTextFormat.PlainText,
+            text_edit=lsp.TextEdit(
+                range=lsp.Range(
+                    start=lsp.Position(line=position.line, character=start),
+                    end=lsp.Position(line=position.line, character=end),
+                ),
+                new_text=new_text,
+            ),
+        ))
+    return items
 
 
 def completion_context(
     source_lines: Sequence[str], position: lsp.Position
 ) -> CompletionContext:
-    if position.line < 0 or position.line >= len(source_lines):
+    prefix = line_prefix_at_position(source_lines, position)
+    if prefix is None:
         return CompletionContext.GENERAL
-
-    line = source_lines[position.line]
-    prefix = line[: _codepoint_offset(line, position.character)]
     if _VARIABLE_PREFIX_RE.search(prefix):
         return CompletionContext.VARIABLE
     if _COMMAND_PREFIX_RE.search(prefix):
@@ -179,8 +261,8 @@ class CompletionCollector(Visitor):
         # Collect variables set with explicit global namespace: set ::var_name ...
         elif routine.contents == "set" and command.args:
             first = command.args[0]
-            if isinstance(first, BareWord) and getattr(first, "value", None):
-                var_name = first.value
+            var_name = variable_name(first)
+            if var_name:
                 if var_name.startswith("::"):
                     base_name = var_name.split("(", 1)[0]
                     clean_name = base_name[2:]  # remove leading '::' for completion display

server/src/tools/navigation.py

@@ -4,7 +4,8 @@ from dataclasses import dataclass
 from pathlib import Path
 
 import lsprotocol.types as lsp
-from tclint.syntax_tree import Command, List, Node, Script, VarSub
+from tclint.syntax_tree import Command, List, Node, QuotedWord, Script, VarSub
+from tools.variable_names import array_key_parts, variable_name
 
 ROOT_NAMESPACE = "::"
 
@@ -27,6 +28,9 @@ class SymbolOccurrence:
     fallback_identity: SymbolIdentity | None = None
     caller: SymbolIdentity | None = None
     declaration_range: lsp.Range | None = None
+    array_element: str | None = None
+    array_parts: tuple[str | None, ...] = ()
+    array_template_parts: tuple[str | None, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -96,6 +100,8 @@ def _name_range(node: Node, raw_name: str, *, variable_sub: bool = False) -> lsp
         column += 2 if getattr(node, "braced", False) else 1
     else:
         position = getattr(node, "contents_pos", None) or node.pos
+        if isinstance(node, QuotedWord) and node.contents is None and node.children:
+            position = node.children[0].pos
         line, column = position
 
     normalized = _without_array_index(raw_name)
@@ -312,6 +318,13 @@ def build_file_symbol_index(
                 is_definition=is_definition,
                 symbol_kind=lsp.SymbolKind.Variable,
                 container_name=_container_name(symbol_identity),
+                array_element=(
+                    raw_name.split("(", 1)[1][:-1]
+                    if "(" in raw_name and raw_name.endswith(")")
+                    else None
+                ),
+                array_parts=array_key_parts(node),
+                array_template_parts=array_key_parts(node, preserve_variables=True),
             )
         )
 
@@ -444,7 +457,7 @@ def build_file_symbol_index(
         for node, is_definition in _variable_command_nodes(command):
             if id(node) in declaration_ids:
                 continue
-            raw_name = _static_contents(node)
+            raw_name = variable_name(node)
             if raw_name:
                 add_variable(
                     node,

server/src/tools/semantic_tokens.py

@@ -5,6 +5,7 @@ import attrs
 from common.load_data import standard_items
 from tclint.commands.plugins import PluginManager
 from tclint.syntax_tree import BareWord, Command, QuotedWord, Visitor
+from tools.variable_names import variable_name
 
 # Constructing a PluginManager scans entry points, and get_commands() rebuilds
 # the builtin command set on every call. Semantic tokens are requested often, so
@@ -159,6 +160,11 @@ class _Highlighter(Visitor):
         if routine.contents == "set" and command.args:
             first_arg = command.args[0]
             token_info = self._get_token_info(first_arg)
+            if first_arg.contents is None:
+                name = variable_name(first_arg)
+                if name:
+                    line, col = first_arg.children[0].pos
+                    token_info = ((line - 1, col - 1), len(name))
             if token_info:
                 (line, col), length = token_info
                 self._append_token((line, col), length, "variable", [TokenModifier.declaration])

server/src/tools/variable_index.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, List, Set
 
 from tclint.syntax_tree import Command, Node, Script
+from tclint.syntax_tree import List as TclList
+from tools.variable_names import variable_name
 
 
 @dataclass
@@ -18,13 +19,14 @@ def _normalize_var_name(raw_name: str | None) -> str | None:
         return None
 
     base = raw_name.split("(", 1)[0]
-    if base.startswith("::"):
-        base = base[2:]
+    base = base.removeprefix("::")
 
     return base or None
 
 
-def build_variable_index(source: str, tree: Node | None = None) -> tuple[Set[str], Dict[str, Set[str]], List[ProcRange]]:
+def build_variable_index(
+    source: str, tree: Node | None = None
+) -> tuple[set[str], dict[str, set[str]], list[ProcRange]]:
     """
     Parse Tcl source text and build:
     - globals: set of variable names considered global suggestions
@@ -40,9 +42,9 @@ def build_variable_index(source: str, tree: Node | None = None) -> tuple[Set[str
     """
     _ = source  # Kept for signature compatibility with callers.
 
-    globals_set: Set[str] = set()
-    procs: Dict[str, Set[str]] = {}
-    proc_ranges: List[ProcRange] = []
+    globals_set: set[str] = set()
+    procs: dict[str, set[str]] = {}
+    proc_ranges: list[ProcRange] = []
 
     if tree is None:
         return globals_set, procs, proc_ranges
@@ -54,7 +56,16 @@ def build_variable_index(source: str, tree: Node | None = None) -> tuple[Set[str
             if routine == "proc" and len(node.args) >= 3 and isinstance(node.args[2], Script):
                 proc_name = _normalize_var_name(getattr(node.args[0], "contents", None))
                 if proc_name is not None:
-                    procs.setdefault(proc_name, set())
+                    local_variables = procs.setdefault(proc_name, set())
+                    for parameter in getattr(node.args[1], "children", []):
+                        parameter_node = parameter
+                        if isinstance(parameter, TclList) and parameter.children:
+                            parameter_node = parameter.children[0]
+                        parameter_name = _normalize_var_name(
+                            getattr(parameter_node, "contents", None)
+                        )
+                        if parameter_name is not None:
+                            local_variables.add(parameter_name)
                     proc_ranges.append(
                         ProcRange(
                             name=proc_name,
@@ -71,7 +82,7 @@ def build_variable_index(source: str, tree: Node | None = None) -> tuple[Set[str
                 return
 
             if routine == "set" and node.args:
-                raw_name = getattr(node.args[0], "contents", None)
+                raw_name = variable_name(node.args[0])
                 base = _normalize_var_name(raw_name)
                 if base is not None:
                     if raw_name and raw_name.startswith("::"):

server/src/tools/variable_names.py

@@ -0,0 +1,44 @@
+"""Extract statically known variable names without evaluating Tcl substitutions."""
+
+from tclint.syntax_tree import BareWord, CompoundBareWord, Node, QuotedWord, VarSub
+
+
+def variable_name(node: Node) -> str | None:
+    contents = node.contents
+    if isinstance(contents, str):
+        return contents
+    if isinstance(node, (CompoundBareWord, QuotedWord)) and node.children:
+        first = node.children[0]
+        last = node.children[-1]
+        if (
+            isinstance(first, BareWord)
+            and isinstance(last, BareWord)
+            and "(" in first.value
+            and last.value.endswith(")")
+        ):
+            # Substitutions in an array index do not change the array's name.
+            return first.value.split("(", 1)[0] or None
+    return None
+
+
+def array_key_parts(node: Node, *, preserve_variables: bool = False) -> tuple[str | None, ...]:
+    """Keep comma-separated literal index components; substitutions are unknown."""
+    contents = node.contents
+    if not isinstance(contents, str):
+        if not isinstance(node, (CompoundBareWord, QuotedWord)) or not variable_name(node):
+            return ()
+        chunks = []
+        for child in node.children:
+            if isinstance(child, BareWord):
+                chunks.append(child.value)
+            elif preserve_variables and isinstance(child, VarSub) and not child.children:
+                chunks.append("${" + child.value + "}" if child.braced else "$" + child.value)
+            else:
+                chunks.append("\0")
+        contents = "".join(chunks)
+    if "(" not in contents or not contents.endswith(")"):
+        return ()
+    return tuple(
+        part if part and not any(char in part for char in ("\0[]\\" if preserve_variables else "\0$[]\\")) else None
+        for part in contents.split("(", 1)[1][:-1].split(",")
+    )

server/tests/python_tests/test_completion_context.py

@@ -6,18 +6,24 @@ SRC_DIR = THIS_DIR.parent.parent / "src"
 if str(SRC_DIR) not in sys.path:
     sys.path.insert(0, str(SRC_DIR))
 
-import lsp_server
 import lsprotocol.types as lsp  # type: ignore
-from common.load_data import standard_items
-from lsp_tclserver import TclLanguageServer
 from pygls.workspace import Workspace
 from pygls.workspace.text_document import TextDocument
+
+import lsp_server
+from common.load_data import standard_items
+from lsp_tclserver import TclLanguageServer
 from tools.completion_items import (
     COMMAND_KINDS,
     VARIABLE_KINDS,
     CompletionContext,
     completion_context,
 )
+from tools.tcl_command_completion import (
+    DynamicCompletionKind,
+    path_completion_items,
+    tcl_argument_completion,
+)
 
 
 def _position_after(source: str, token: str, occurrence: int = 0) -> lsp.Position:
@@ -90,6 +96,149 @@ def _complete(document: TextDocument, position: lsp.Position):
     ).items
 
 
+def _argument_completion_labels(source: str) -> set[str] | None:
+    completion = _argument_completion_request(source)
+    if completion is None:
+        return None
+    return {item.label for item in completion.items}
+
+
+def test_array_keys_complete_in_set_and_substitution(tmp_path: Path, monkeypatch):
+    server, _, _ = _completion_server(tmp_path, monkeypatch)
+    workspace = _document(
+        tmp_path / "arrays.tcl",
+        "set ::lib_flag(enabled) 1\nset ::lib_flag(external) 1\n",
+    )
+    assert server.update_poco_completion_for_file(workspace)
+    source = (
+        "set lib_flag(enabled) 0\n"
+        "set lib_flag(empty) 1\n"
+        "set other(wrong) 1\n"
+        "proc hidden {} { set lib_flag(private) 1 }\n"
+        "set lib_flag()\n"
+        "puts $lib_flag(en)\n"
+        "puts 😀; set lib_flag(em\n"
+    )
+    current = _document(tmp_path / "arrays-current.tcl", source)
+    server.workspace.put_text_document(lsp.TextDocumentItem(
+        uri=current.uri, language_id="tcl", version=1, text=source,
+    ))
+    assert server.update_poco_completion_for_file(current)
+    items = _complete(current, _position_after(source, "set lib_flag(", 3))
+    assert [item.label for item in items] == ["empty", "enabled", "external"]
+    assert all(item.text_edit.new_text == item.label for item in items)
+    items = _complete(current, _position_after(source, "puts $lib_flag(en"))
+    assert [item.label for item in items] == ["enabled"]
+    assert items[0].text_edit.new_text == "enabled"
+    position = lsp.Position(line=6, character=len(source.splitlines()[6].encode("utf-16-le")) // 2)
+    items = _complete(current, position)
+    assert [item.label for item in items] == ["empty"]
+    assert items[0].text_edit.new_text == "empty)"
+    assert items[0].text_edit.range.start.character == position.character - 2
+
+
+def test_dynamic_array_index_keeps_variable_identity(tmp_path: Path, monkeypatch):
+    from tools.navigation import build_file_symbol_index
+    from tools.parser import CustomParser
+    from tools.semantic_tokens import _Highlighter
+    from tools.variable_index import build_variable_index
+    from tools.variable_names import variable_name
+
+    source = (
+        "set custom_flag(from_move,$::mom_path_name) 1\n"
+        'set "::quoted_flag(from_move,$::mom_path_name)" 1\n'
+        "set ::command_flag([info hostname]) 1\n"
+        "set ${dynamic_name}(entry) 1\n"
+        "proc example {} { set local_flag($::mom_path_name) 1 }\n"
+        "puts $custom_flag\n"
+    )
+    tree = CustomParser().parse(source)
+    globals_, locals_, _ = build_variable_index(source, tree)
+    assert {"custom_flag", "quoted_flag", "command_flag"} <= globals_
+    assert locals_["example"] == {"local_flag"}
+    assert variable_name(tree.children[3].args[0]) is None
+    path = tmp_path / "dynamic.tcl"
+    index = build_file_symbol_index(str(path), path.as_uri(), tree)
+    definition = next(
+        item for item in index.occurrences
+        if item.identity.name == "::custom_flag" and item.is_definition
+    )
+    assert definition.range.start.character == 4
+    assert definition.range.end.character == 15
+    assert definition.array_element is None
+    assert any(item.identity.name == "::mom_path_name" for item in index.occurrences)
+    highlighter = _Highlighter([], {})
+    tree.accept(highlighter, recurse=True)
+    assert any(
+        position == (0, 4) and length == 11 and kind == "variable"
+        for position, length, kind, _ in highlighter._tokens
+    )
+    server, _, _ = _completion_server(tmp_path, monkeypatch)
+    current = _document(path, source)
+    server.workspace.put_text_document(lsp.TextDocumentItem(
+        uri=current.uri, language_id="tcl", version=1, text=source,
+    ))
+    assert server.update_poco_completion_for_file(current)
+    items = _complete(current, _position_after(source, "puts $custom"))
+    assert "custom_flag" in {item.label for item in items}
+    workspace_items = next(
+        items for item_path, items in server.completion_items_by_file_snapshot().items()
+        if server.paths_equal(item_path, str(path))
+    )
+    assert {"quoted_flag", "command_flag"} <= {item.label for item in workspace_items}
+
+
+def test_literal_array_components_complete_around_substitutions(tmp_path: Path, monkeypatch):
+    from tools.completion_items import array_element_completions
+
+    server, _, _ = _completion_server(tmp_path, monkeypatch)
+    source = (
+        "set custom_flag(from_move,$::mom_path_name) 1\n"
+        "set custom_flag(to_move,$::mom_path_name) 1\n"
+        "set custom_flag($::mom_path_name,finished) 1\n"
+        "set custom_flag(prefix_$::mom_path_name,other) 1\n"
+        "set custom_flag([info hostname],command_tail) 1\n"
+        "set other_flag(wrong,$::mom_path_name) 1\n"
+        "set multi_flag(move,$first,axis,$second) 1\n"
+    )
+    document = _document(tmp_path / "components.tcl", source)
+    assert server.update_poco_completion_for_file(document)
+    cases = [
+        ("set custom_flag(|,$::mom_path_name)", {"from_move", "to_move"}, "from_move", "set custom_flag(from_move,$::mom_path_name)"),
+        ("set custom_flag(fr|om_old,$::mom_path_name)", {"from_move"}, "from_move", "set custom_flag(from_move,$::mom_path_name)"),
+        ("puts $custom_flag($::mom_path_name,fi|)", {"finished"}, "finished", "puts $custom_flag($::mom_path_name,finished)"),
+        ("set custom_flag($::mom_path_name,|)", {"finished", "other", "command_tail"}, "other", "set custom_flag($::mom_path_name,other)"),
+        ("set custom_flag(fr|", {"from_move"}, "from_move", "set custom_flag(from_move,$::mom_path_name)"),
+        ("set custom_flag(fr|)", {"from_move"}, "from_move", "set custom_flag(from_move,$::mom_path_name)"),
+        ("set multi_flag(m|)", {"move"}, "move", "set multi_flag(move,$first,axis,$second)"),
+    ]
+    for marked, labels, selected, expected in cases:
+        offset = marked.index("|")
+        line = marked.replace("|", "")
+        items = array_element_completions(
+            [line], lsp.Position(line=0, character=offset),
+            server.navigation_snapshot().values(), str(tmp_path / "caller.tcl"),
+        )
+        assert {item.label for item in items} == labels
+        edit = next(item.text_edit for item in items if item.label == selected)
+        item = next(item for item in items if item.label == selected)
+        assert item.insert_text_format == lsp.InsertTextFormat.PlainText
+        assert line[:edit.range.start.character] + edit.new_text + line[edit.range.end.character:] == expected
+    assert array_element_completions(
+        ["set custom_flag(from_move,$::mom"], lsp.Position(line=0, character=31),
+        server.navigation_snapshot().values(), str(tmp_path / "caller.tcl"),
+    ) is None
+
+
+def _argument_completion_request(source: str):
+    lines = source.split("\n")
+    character = len(lines[-1].encode("utf-16-le")) // 2
+    return tcl_argument_completion(
+        lines,
+        lsp.Position(line=len(lines) - 1, character=character),
+    )
+
+
 def test_variable_completion_filters_and_ranks_candidates(tmp_path: Path, monkeypatch):
     _, current, source = _completion_server(tmp_path, monkeypatch)
     items = _complete(current, _position_after(source, "$local"))
@@ -150,3 +299,339 @@ def test_completion_context_handles_nested_commands_and_utf16():
         completion_context(["puts value"], lsp.Position(line=0, character=10))
         == CompletionContext.GENERAL
     )
+
+
+def test_string_subcommands_and_compare_options_are_context_aware():
+    subcommands = _argument_completion_labels("string ")
+    assert subcommands is not None
+    assert {"compare", "equal", "is", "map", "match"} <= subcommands
+
+    assert _argument_completion_labels("string compare ") == {
+        "-length",
+        "-nocase",
+    }
+    assert _argument_completion_labels("string compare -nocase ") == {
+        "-length"
+    }
+    assert _argument_completion_labels("string compare -length ") is None
+
+
+def test_string_completion_handles_nested_commands_and_is_values():
+    assert _argument_completion_labels("set result [string compare -") == {
+        "-length",
+        "-nocase",
+    }
+
+    classes = _argument_completion_labels("string is ")
+    assert classes is not None
+    assert {"boolean", "double", "integer", "wideinteger"} <= classes
+    assert _argument_completion_labels("string is integer ") == {
+        "-failindex",
+        "-strict",
+    }
+
+
+def test_string_completion_inside_braced_conditions_and_bodies():
+    for prefix in ("if {", "while {", "proc example {} { if {"):
+        subcommands = _argument_completion_labels(prefix + "[string ")
+        assert subcommands is not None
+        assert {"compare", "equal", "is"} <= subcommands
+        assert _argument_completion_labels(prefix + "[string compare -") == {
+            "-length", "-nocase"
+        }
+        assert _argument_completion_labels(
+            prefix + "[string compare -nocase "
+        ) == {"-length"}
+
+
+def test_closed_braced_arguments_do_not_change_completion_context():
+    assert _argument_completion_labels("puts {[string compare }") is None
+    assert _argument_completion_labels(
+        "if {[string equal a b]} {string compare "
+    ) == {"-length", "-nocase"}
+    assert _argument_completion_labels(
+        "if {[string equal a b] && [string is integer "
+    ) == {"-failindex", "-strict"}
+
+
+def test_dict_array_namespace_file_and_info_subcommands():
+    dict_items = _argument_completion_labels("dict ")
+    assert dict_items is not None
+    assert {"create", "filter", "get", "set", "with"} <= dict_items
+    assert _argument_completion_labels("dict filter ") == {
+        "key",
+        "script",
+        "value",
+    }
+
+    assert _argument_completion_labels("array names values ") == {
+        "-exact",
+        "-glob",
+        "-regexp",
+    }
+
+    namespace_items = _argument_completion_labels("namespace ")
+    assert namespace_items is not None
+    assert {"children", "ensemble", "eval", "which"} <= namespace_items
+    assert _argument_completion_labels("namespace which ") == {
+        "-command",
+        "-variable",
+    }
+    assert _argument_completion_labels("namespace ensemble ") == {
+        "configure",
+        "create",
+        "exists",
+    }
+
+    file_items = _argument_completion_labels("file ")
+    assert file_items is not None
+    assert {"copy", "delete", "exists", "normalize", "rename"} <= file_items
+    assert _argument_completion_labels("file copy ") == {"--", "-force"}
+
+    info_items = _argument_completion_labels("info ")
+    assert info_items is not None
+    assert {"args", "body", "commands", "exists", "procs", "vars"} <= info_items
+
+
+def test_variable_context_still_takes_priority_inside_tcl_command(
+    tmp_path: Path, monkeypatch
+):
+    _, current, source = _completion_server(tmp_path, monkeypatch)
+    command_source = source.replace(
+        "    puts $local\n",
+        "    puts $local\n    string compare $localValue other\n",
+    )
+    current = _document(tmp_path / "current.tcl", command_source)
+    lsp_server.LSP_SERVER.workspace.put_text_document(
+        lsp.TextDocumentItem(
+            uri=current.uri,
+            language_id="tcl",
+            version=2,
+            text=command_source,
+        )
+    )
+    items = _complete(current, _position_after(command_source, "$localValue"))
+
+    assert items
+    assert all(item.kind in VARIABLE_KINDS for item in items)
+    assert "localValue" in {item.label for item in items}
+
+
+def test_lsp_completion_returns_only_matching_command_options(
+    tmp_path: Path, monkeypatch
+):
+    _, current, _ = _completion_server(tmp_path, monkeypatch)
+    source = "string compare "
+    current = _document(tmp_path / "current.tcl", source)
+    lsp_server.LSP_SERVER.workspace.put_text_document(
+        lsp.TextDocumentItem(
+            uri=current.uri,
+            language_id="tcl",
+            version=2,
+            text=source,
+        )
+    )
+
+    items = _complete(current, _position_after(source, source))
+
+    assert {item.label for item in items} == {"-length", "-nocase"}
+    assert all(item.kind == lsp.CompletionItemKind.Keyword for item in items)
+    assert all(item.sort_text.startswith("000:") for item in items)
+
+
+def test_space_trigger_does_not_open_broad_fallback_completion(
+    tmp_path: Path, monkeypatch
+):
+    _, current, _ = _completion_server(tmp_path, monkeypatch)
+    source = "set value "
+    current = _document(tmp_path / "current.tcl", source)
+    lsp_server.LSP_SERVER.workspace.put_text_document(
+        lsp.TextDocumentItem(
+            uri=current.uri,
+            language_id="tcl",
+            version=2,
+            text=source,
+        )
+    )
+
+    result = lsp_server.on_completion(
+        lsp.CompletionParams(
+            text_document=lsp.TextDocumentIdentifier(uri=current.uri),
+            position=_position_after(source, source),
+            context=lsp.CompletionContext(
+                trigger_kind=lsp.CompletionTriggerKind.TriggerCharacter,
+                trigger_character=" ",
+            ),
+        )
+    )
+
+    assert result.items == []
+
+
+def test_argument_values_are_suggested_at_the_expected_position():
+    assert _argument_completion_labels("return -code ") == {
+        "break",
+        "continue",
+        "error",
+        "ok",
+        "return",
+    }
+    assert _argument_completion_labels("open output.txt ") == {
+        "a",
+        "a+",
+        "r",
+        "r+",
+        "w",
+        "w+",
+    }
+    assert _argument_completion_labels("seek channel 0 ") == {
+        "current",
+        "end",
+        "start",
+    }
+
+
+def test_dynamic_argument_categories_are_detected():
+    variable = _argument_completion_request("set ")
+    procedure = _argument_completion_request("info body ")
+    namespace = _argument_completion_request("namespace eval ")
+    path = _argument_completion_request("source scripts/")
+
+    assert variable is not None
+    assert variable.dynamic_kind == DynamicCompletionKind.VARIABLE
+    assert procedure is not None
+    assert procedure.dynamic_kind == DynamicCompletionKind.PROCEDURE
+    assert namespace is not None
+    assert namespace.dynamic_kind == DynamicCompletionKind.NAMESPACE
+    assert path is not None
+    assert path.dynamic_kind == DynamicCompletionKind.PATH
+    assert path.path_extensions == (".tcl",)
+
+
+def test_path_completion_is_relative_filtered_and_tcl_safe(tmp_path: Path):
+    scripts = tmp_path / "scripts"
+    scripts.mkdir()
+    (scripts / "first file.tcl").write_text("puts ok", encoding="utf-8")
+    (scripts / "ignored.txt").write_text("ignored", encoding="utf-8")
+
+    source = "source scripts/f"
+    completion = _argument_completion_request(source)
+    assert completion is not None
+    items = path_completion_items(
+        tmp_path,
+        completion,
+        _position_after(source, source),
+    )
+
+    assert [item.label for item in items] == ["scripts/first\\ file.tcl"]
+    assert items[0].kind == lsp.CompletionItemKind.File
+    assert items[0].text_edit is not None
+    assert items[0].text_edit.new_text == "scripts/first\\ file.tcl"
+    assert items[0].text_edit.range.start.character == len("source ")
+
+
+def test_lsp_source_completion_reads_paths_from_document_directory(
+    tmp_path: Path, monkeypatch
+):
+    server, current, _ = _completion_server(tmp_path, monkeypatch)
+    scripts = tmp_path / "scripts"
+    scripts.mkdir()
+    (scripts / "helper.tcl").write_text("proc helper {} {}", encoding="utf-8")
+    (scripts / "ignored.txt").write_text("ignored", encoding="utf-8")
+    source = "source scripts/"
+    current = _document(tmp_path / "current.tcl", source)
+    server.workspace.put_text_document(
+        lsp.TextDocumentItem(
+            uri=current.uri,
+            language_id="tcl",
+            version=2,
+            text=source,
+        )
+    )
+
+    items = _complete(current, _position_after(source, source))
+    labels = {item.label for item in items}
+
+    assert "scripts/helper.tcl" in labels
+    assert "scripts/ignored.txt" not in labels
+
+
+def test_command_and_dict_for_snippets_use_lsp_snippet_placeholders(
+    tmp_path: Path, monkeypatch
+):
+    _, current, source = _completion_server(tmp_path, monkeypatch)
+    command_items = _complete(current, _position_after(source, "localP", occurrence=1))
+    command_by_label = {item.label: item for item in command_items}
+
+    assert command_by_label["if"].kind == lsp.CompletionItemKind.Snippet
+    assert command_by_label["if"].insert_text_format == lsp.InsertTextFormat.Snippet
+    assert "${1:condition}" in (command_by_label["if"].insert_text or "")
+
+    dict_for = _argument_completion_request("dict f")
+    assert dict_for is not None
+    for_item = next(item for item in dict_for.items if item.label == "for")
+    assert for_item.kind == lsp.CompletionItemKind.Snippet
+    assert "${3:dictionary}" in (for_item.insert_text or "")
+
+    switch_arguments = _argument_completion_request("switch ")
+    assert switch_arguments is not None
+    assert {"switch block", "-exact", "-glob", "-regexp"} <= {
+        item.label for item in switch_arguments.items
+    }
+
+
+def test_semantic_variable_and_procedure_argument_completion(
+    tmp_path: Path, monkeypatch
+):
+    _, current, source = _completion_server(tmp_path, monkeypatch)
+
+    variable_items = _complete(current, _position_after(source, "    set "))
+    assert variable_items
+    assert all(item.kind in VARIABLE_KINDS for item in variable_items)
+    assert {"argument", "localValue"} <= {item.label for item in variable_items}
+
+    procedure_source = source + "info body localProc\n"
+    current = _document(tmp_path / "current.tcl", procedure_source)
+    lsp_server.LSP_SERVER.workspace.put_text_document(
+        lsp.TextDocumentItem(
+            uri=current.uri,
+            language_id="tcl",
+            version=2,
+            text=procedure_source,
+        )
+    )
+    procedure_items = _complete(
+        current,
+        _position_after(procedure_source, "info body "),
+    )
+    procedure_labels = {item.label for item in procedure_items}
+
+    assert "localProc" in procedure_labels
+    assert "workspaceProc" in procedure_labels
+    assert "MOM_abort" in procedure_labels
+    assert "localValue" not in procedure_labels
+    assert "string" not in procedure_labels
+
+
+def test_namespace_argument_completion_uses_navigation_index(
+    tmp_path: Path, monkeypatch
+):
+    server, current, _ = _completion_server(tmp_path, monkeypatch)
+    namespace_source = "namespace eval tools { proc helper {} { return } }\n"
+    namespace_document = _document(tmp_path / "namespaces.tcl", namespace_source)
+    assert server.update_poco_completion_for_file(namespace_document)
+
+    source = "namespace eval "
+    current = _document(tmp_path / "current.tcl", source)
+    server.workspace.put_text_document(
+        lsp.TextDocumentItem(
+            uri=current.uri,
+            language_id="tcl",
+            version=2,
+            text=source,
+        )
+    )
+    items = _complete(current, _position_after(source, source))
+
+    assert "tools" in {item.label for item in items}
+    assert all(item.kind == lsp.CompletionItemKind.Module for item in items)

syntaxes/def.tmLanguage.json

@@ -5,6 +5,9 @@
 		{
 			"include": "#comment"
 		},
+		{
+			"include": "#escaped-quoted-strings"
+		},
 		{
 			"include": "#strings"
 		},
@@ -28,6 +31,31 @@
 		}
 	],
 	"repository": {
+		"escaped-quoted-strings": {
+			"name": "string.quoted.double.def",
+			"begin": "\\\\\"",
+			"end": "\\\\\"",
+			"beginCaptures": {
+				"0": {
+					"name": "punctuation.definition.string.begin.def"
+				}
+			},
+			"endCaptures": {
+				"0": {
+					"name": "punctuation.definition.string.end.def"
+				}
+			},
+			"patterns": [
+				{
+					"name": "constant.character.escape.def",
+					"match": "\\\\."
+				},
+				{
+					"name": "variable.other.property",
+					"match": "\\$[_a-zA-Z][_a-zA-Z0-9]*(\\(\\$?[_a-zA-Z][_a-zA-Z0-9]*(,\\$?[_a-zA-Z][_a-zA-Z0-9]*)*\\))?"
+				}
+			]
+		},
 		"keywords": {
 			"patterns": [
 				{

test/test.tcl

@@ -117,7 +117,6 @@ proc SERVICE_get_tool_data {} {
     }
 }
 
-
 LIB_GE_command_buffer_edit_replace MOM_end_of_program_LIB END_OF_PROGRAM @END_OF_PROG {
     MOM_do_template "end_of_program_rewind"
 } EndOfProgramRewind