umple-lsp-server 0.4.2 → 1.0.0

package/out/completionBuilder.js

@@ -15,7 +15,23 @@ exports.symbolKindToCompletionKind = symbolKindToCompletionKind;
 exports.buildSemanticCompletionItems = buildSemanticCompletionItems;
 const node_1 = require("vscode-languageserver/node");
 const keywords_1 = require("./keywords");
+const snippets_1 = require("./snippets");
 const path = require("path");
+/**
+ * Topic 054 — emit snippet completion items for the given scope when the
+ * client advertised snippet support. No-op for typed-prefix / suppress /
+ * symbol-only scopes (they have no snippet entries registered).
+ */
+function appendSnippetsForScope(items, seen, scope, snippetSupport) {
+    if (!snippetSupport)
+        return;
+    for (const entry of (0, snippets_1.getSnippetsForScope)(scope)) {
+        if (seen.has(entry.label))
+            continue;
+        seen.add(entry.label);
+        items.push((0, snippets_1.snippetEntryToItem)(entry));
+    }
+}
 // ── Curated top-level construct keywords ───────────────────────────────────
 // Derived from the grammar's _definition rule (grammar.js lines 66-92).
 // Raw parser lookahead is NOT surfaced at this scope.
@@ -57,7 +73,7 @@ const CLASS_BODY_KEYWORDS = [
     // Trace
     "trace", "tracecase",
     // Nested definitions
-    "class", "enum", "mixset",
+    "inner", "class", "enum", "mixset",
     // Class-level declarations
     "abstract", "singleton",
     // Attribute modifiers
@@ -196,40 +212,18 @@ const ASSOCIATION_MULTIPLICITY_STARTERS = [
     "1..*",
     "0..*",
 ];
-// ── Constraint keyword blocklist ────────────────────────────────────────────
-const CONSTRAINT_BLOCKLIST = new Set([
-    "ERROR",
-    // Top-level definition keywords
-    "namespace", "class", "interface", "trait", "abstract",
-    "association", "associationClass", "statemachine",
-    "enum", "external", "mixset",
-    // Generate statement + all targets
-    "generate", "Java", "Nothing", "Php", "RTCpp", "SimpleCpp",
-    "Ruby", "Python", "Cpp", "Json", "StructureDiagram", "Yuml",
-    "Violet", "Umlet", "Simulate", "TextUml", "Scxml",
-    "GvStateDiagram", "GvClassDiagram", "GvFeatureDiagram",
-    "GvClassTraitDiagram", "GvEntityRelationshipDiagram",
-    "Alloy", "NuSMV", "NuSMVOptimizer", "Papyrus", "Ecore", "Xmi",
-    "Xtext", "Sql", "StateTables", "EventSequence", "InstanceDiagram",
-    "Umple", "UmpleSelf", "USE", "Test", "SimpleMetrics",
-    "PlainRequirementsDoc", "Uigu2", "ExternalGrammar", "Mermaid",
-    // Other top-level directives
-    "use", "strictness",
-    // Class-level keywords invalid inside constraints
-    "isA", "req", "require", "subfeature", "isFeature",
-    "depend", "singleton", "displayColor", "displayColour",
-    "implementsReq", "filter", "includeFilter",
-    // Trace/SM/attribute keywords that can't appear in expressions
-    "trace", "tracecase", "activate", "deactivate",
-    "onAllObjects", "onThisThreadOnly", "onThisObject",
-    "where", "until", "giving", "record",
-    "queued", "pooled", "as",
-    "key", "immutable", "unique", "lazy", "settable",
-    "internal", "defaulted", "autounique",
-    "entry", "exit", "do",
-    "emit", "around", "custom", "generated",
-    "include", "hops", "super", "sub",
-]);
+// All seven Umple association arrow operators, mirroring the grammar rule
+//   arrow: choice("--", "->", "<-", "<@>-", "-<@>", ">->", "<-<")
+// Offered after the left multiplicity (`1 |`) before the arrow is committed.
+const ASSOCIATION_ARROW_STARTERS = [
+    "--",
+    "->",
+    "<-",
+    "<@>-",
+    "-<@>",
+    ">->",
+    "<-<",
+];
 // ── Kind → CompletionItemKind mapping ───────────────────────────────────────
 function symbolKindToCompletionKind(kind) {
     switch (kind) {
@@ -245,8 +239,12 @@ function symbolKindToCompletionKind(kind) {
             return node_1.CompletionItemKind.EnumMember;
         case "statemachine":
             return node_1.CompletionItemKind.Enum;
+        case "event":
+            return node_1.CompletionItemKind.Event;
         case "attribute":
             return node_1.CompletionItemKind.Field;
+        case "port":
+            return node_1.CompletionItemKind.Property;
         case "const":
             return node_1.CompletionItemKind.Constant;
         case "method":
@@ -263,6 +261,69 @@ function symbolKindToCompletionKind(kind) {
             return node_1.CompletionItemKind.Text;
     }
 }
+/**
+ * Append symbols of the given kinds into `items`/`seen`. Each kind is looked
+ * up either globally (no `container`) or container-scoped with optional
+ * inheritance. Dedup is by label against the shared `seen` set, so callers
+ * can interleave this with curated keyword / built-in emission.
+ *
+ * Order: kinds iterated in declared order; within a kind, whatever order
+ * `symbolIndex.getSymbols` returns.
+ */
+function appendSymbolsOfKinds(items, seen, symbolIndex, reachableFiles, opts) {
+    for (const symKind of opts.kinds) {
+        const query = opts.container !== undefined
+            ? { container: opts.container, kind: symKind, inherited: opts.inherited }
+            : { kind: symKind };
+        const symbols = symbolIndex
+            .getSymbols(query)
+            .filter((s) => reachableFiles.has(path.normalize(s.file)));
+        for (const sym of symbols) {
+            if (!seen.has(sym.name)) {
+                seen.add(sym.name);
+                items.push({
+                    label: sym.name,
+                    kind: symbolKindToCompletionKind(symKind),
+                    detail: symKind,
+                });
+            }
+        }
+    }
+}
+/**
+ * Assemble a symbol-only completion list: optional built-ins followed by
+ * named symbols across the given kinds. A single dedup Set shares across
+ * built-ins and symbols so a user-defined type that shadows a built-in name
+ * (rare) doesn't appear twice.
+ *
+ * Used by every typed-prefix scope and by `association_type`. Preserves the
+ * exact emission ordering the pre-refactor branches relied on:
+ *   1. built-ins in BUILTIN_TYPES order (optionally skipping `void`)
+ *   2. symbols per-kind, kinds iterated in declared order
+ *   3. within each kind, whatever order `SymbolIndex.getSymbols` returns
+ */
+function buildTypeCompletionItems(symbolIndex, reachableFiles, opts) {
+    const items = [];
+    const seen = new Set();
+    if (opts.includeBuiltins) {
+        for (const typ of keywords_1.BUILTIN_TYPES) {
+            if (opts.excludeVoid && typ === "void")
+                continue;
+            if (!seen.has(typ)) {
+                seen.add(typ);
+                items.push({
+                    label: typ,
+                    kind: node_1.CompletionItemKind.TypeParameter,
+                    detail: "built-in",
+                });
+            }
+        }
+    }
+    appendSymbolsOfKinds(items, seen, symbolIndex, reachableFiles, {
+        kinds: opts.kinds,
+    });
+    return items;
+}
 // ── Main builder ────────────────────────────────────────────────────────────
 /**
  * Build semantic completion items from a CompletionInfo + SymbolIndex.
@@ -277,15 +338,16 @@ function symbolKindToCompletionKind(kind) {
  * @param symbolKinds - the normalized symbolKinds (after use_path → mixset conversion).
  *   Caller should not pass "suppress", "use_path", isComment, or isDefinitionName states.
  */
-function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableFiles) {
-    const items = [];
-    const seen = new Set();
+function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableFiles, snippetSupport = false) {
     // Top-level scope: curated keywords only, no raw lookahead or symbols.
     if (symbolKinds === "top_level") {
-        return TOP_LEVEL_KEYWORDS.map((kw) => ({
+        const tlItems = TOP_LEVEL_KEYWORDS.map((kw) => ({
             label: kw,
             kind: node_1.CompletionItemKind.Keyword,
         }));
+        const tlSeen = new Set(TOP_LEVEL_KEYWORDS);
+        appendSnippetsForScope(tlItems, tlSeen, "top_level", snippetSupport);
+        return tlItems;
     }
     // Class-body scope: curated keywords + built-in types + type symbols.
     if (symbolKinds === "class_body") {
@@ -301,21 +363,10 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
                 cbItems.push({ label: typ, kind: node_1.CompletionItemKind.TypeParameter, detail: "type" });
             }
         }
-        for (const symKind of ["class", "interface", "trait", "enum"]) {
-            const symbols = symbolIndex
-                .getSymbols({ kind: symKind })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of symbols) {
-                if (!cbSeen.has(sym.name)) {
-                    cbSeen.add(sym.name);
-                    cbItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(symKind),
-                        detail: symKind,
-                    });
-                }
-            }
-        }
+        appendSymbolsOfKinds(cbItems, cbSeen, symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait", "enum"],
+        });
+        appendSnippetsForScope(cbItems, cbSeen, "class_body", snippetSupport);
         return cbItems;
     }
     // Trait-body scope: curated keywords + built-in types + type symbols.
@@ -332,21 +383,10 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
                 tbItems.push({ label: typ, kind: node_1.CompletionItemKind.TypeParameter, detail: "type" });
             }
         }
-        for (const symKind of ["class", "interface", "trait", "enum"]) {
-            const symbols = symbolIndex
-                .getSymbols({ kind: symKind })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of symbols) {
-                if (!tbSeen.has(sym.name)) {
-                    tbSeen.add(sym.name);
-                    tbItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(symKind),
-                        detail: symKind,
-                    });
-                }
-            }
-        }
+        appendSymbolsOfKinds(tbItems, tbSeen, symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait", "enum"],
+        });
+        appendSnippetsForScope(tbItems, tbSeen, "trait_body", snippetSupport);
         return tbItems;
     }
     // Interface-body scope: curated keywords + built-in types + type symbols.
@@ -363,21 +403,10 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
                 ibItems.push({ label: typ, kind: node_1.CompletionItemKind.TypeParameter, detail: "type" });
             }
         }
-        for (const symKind of ["class", "interface", "trait", "enum"]) {
-            const symbols = symbolIndex
-                .getSymbols({ kind: symKind })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of symbols) {
-                if (!ibSeen.has(sym.name)) {
-                    ibSeen.add(sym.name);
-                    ibItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(symKind),
-                        detail: symKind,
-                    });
-                }
-            }
-        }
+        appendSymbolsOfKinds(ibItems, ibSeen, symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait", "enum"],
+        });
+        appendSnippetsForScope(ibItems, ibSeen, "interface_body", snippetSupport);
         return ibItems;
     }
     // Association-class-body scope: same as class body (shares _class_content).
@@ -394,49 +423,31 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
                 abItems.push({ label: typ, kind: node_1.CompletionItemKind.TypeParameter, detail: "type" });
             }
         }
-        for (const symKind of ["class", "interface", "trait", "enum"]) {
-            const symbols = symbolIndex
-                .getSymbols({ kind: symKind })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of symbols) {
-                if (!abSeen.has(sym.name)) {
-                    abSeen.add(sym.name);
-                    abItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(symKind),
-                        detail: symKind,
-                    });
-                }
-            }
-        }
+        appendSymbolsOfKinds(abItems, abSeen, symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait", "enum"],
+        });
+        appendSnippetsForScope(abItems, abSeen, "assoc_class_body", snippetSupport);
         return abItems;
     }
     // Filter-body scope: curated filter-statement starters only.
     if (symbolKinds === "filter_body") {
-        return FILTER_BODY_KEYWORDS.map((kw) => ({
+        const fbItems = FILTER_BODY_KEYWORDS.map((kw) => ({
             label: kw,
             kind: node_1.CompletionItemKind.Keyword,
         }));
+        const fbSeen = new Set(FILTER_BODY_KEYWORDS);
+        appendSnippetsForScope(fbItems, fbSeen, "filter_body", snippetSupport);
+        return fbItems;
     }
     // Trace entity scope: scoped attrs/methods only, no raw keywords.
     if (symbolKinds === "trace_attribute_method" && info.enclosingClass) {
         const trItems = [];
         const trSeen = new Set();
-        for (const kind of ["attribute", "method"]) {
-            const symbols = symbolIndex
-                .getSymbols({ container: info.enclosingClass, kind, inherited: true })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of symbols) {
-                if (!trSeen.has(sym.name)) {
-                    trSeen.add(sym.name);
-                    trItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(kind),
-                        detail: kind,
-                    });
-                }
-            }
-        }
+        appendSymbolsOfKinds(trItems, trSeen, symbolIndex, reachableFiles, {
+            kinds: ["attribute", "method"],
+            container: info.enclosingClass,
+            inherited: true,
+        });
         return trItems;
     }
     // Guard scope: scoped attrs/methods + boolean literals only, no raw keywords.
@@ -449,23 +460,36 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
             gItems.push({ label: lit, kind: node_1.CompletionItemKind.Keyword });
         }
         // Scoped attrs + methods from enclosing class
-        for (const kind of ["attribute", "method"]) {
-            const symbols = symbolIndex
-                .getSymbols({ container: info.enclosingClass, kind, inherited: true })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of symbols) {
-                if (!gSeen.has(sym.name)) {
-                    gSeen.add(sym.name);
-                    gItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(kind),
-                        detail: kind,
-                    });
-                }
-            }
-        }
+        appendSymbolsOfKinds(gItems, gSeen, symbolIndex, reachableFiles, {
+            kinds: ["attribute", "method"],
+            container: info.enclosingClass,
+            inherited: true,
+        });
         return gItems;
     }
+    // Constraint scope `[...]`: own attributes only (Umple E28 — no inherited
+    // attrs in constraints). Symbol-only; no raw lookahead, no operators.
+    if (symbolKinds === "own_attribute" && info.enclosingClass) {
+        const oaItems = [];
+        const oaSeen = new Set();
+        appendSymbolsOfKinds(oaItems, oaSeen, symbolIndex, reachableFiles, {
+            kinds: ["attribute"],
+            container: info.enclosingClass,
+        });
+        return oaItems;
+    }
+    // Sorted-key scope `sorted{...}`: attributes of the owner class with
+    // inheritance. Symbol-only; no raw lookahead, no operators.
+    if (symbolKinds === "sorted_attribute" && info.sortedKeyOwner) {
+        const skItems = [];
+        const skSeen = new Set();
+        appendSymbolsOfKinds(skItems, skSeen, symbolIndex, reachableFiles, {
+            kinds: ["attribute"],
+            container: info.sortedKeyOwner,
+            inherited: true,
+        });
+        return skItems;
+    }
     // Transition-target scope: state symbols only, no keywords.
     if (symbolKinds === "transition_target") {
         const ttItems = [];
@@ -482,19 +506,10 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
                 }
             }
             else {
-                const states = symbolIndex
-                    .getSymbols({ kind: "state", container: info.enclosingStateMachine })
-                    .filter((s) => reachableFiles.has(path.normalize(s.file)));
-                for (const sym of states) {
-                    if (!ttSeen.has(sym.name)) {
-                        ttSeen.add(sym.name);
-                        ttItems.push({
-                            label: sym.name,
-                            kind: symbolKindToCompletionKind("state"),
-                            detail: "state",
-                        });
-                    }
-                }
+                appendSymbolsOfKinds(ttItems, ttSeen, symbolIndex, reachableFiles, {
+                    kinds: ["state"],
+                    container: info.enclosingStateMachine,
+                });
             }
         }
         return ttItems;
@@ -513,21 +528,9 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
                 mbItems.push({ label: typ, kind: node_1.CompletionItemKind.TypeParameter, detail: "type" });
             }
         }
-        for (const symKind of ["class", "interface", "trait", "enum"]) {
-            const symbols = symbolIndex
-                .getSymbols({ kind: symKind })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of symbols) {
-                if (!mbSeen.has(sym.name)) {
-                    mbSeen.add(sym.name);
-                    mbItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(symKind),
-                        detail: symKind,
-                    });
-                }
-            }
-        }
+        appendSymbolsOfKinds(mbItems, mbSeen, symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait", "enum"],
+        });
         return mbItems;
     }
     // Statemachine-body scope: curated keywords + state symbols from enclosing SM.
@@ -540,20 +543,12 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
         }
         // Offer existing state names from the enclosing SM
         if (info.enclosingStateMachine) {
-            const states = symbolIndex
-                .getSymbols({ kind: "state", container: info.enclosingStateMachine })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of states) {
-                if (!smSeen.has(sym.name)) {
-                    smSeen.add(sym.name);
-                    smItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind("state"),
-                        detail: "state",
-                    });
-                }
-            }
+            appendSymbolsOfKinds(smItems, smSeen, symbolIndex, reachableFiles, {
+                kinds: ["state"],
+                container: info.enclosingStateMachine,
+            });
         }
+        appendSnippetsForScope(smItems, smSeen, "statemachine_body", snippetSupport);
         return smItems;
     }
     // State-body scope: curated keywords + state symbols + built-in types for methods.
@@ -573,20 +568,12 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
         }
         // Offer state names from enclosing SM (for nested state references)
         if (info.enclosingStateMachine) {
-            const states = symbolIndex
-                .getSymbols({ kind: "state", container: info.enclosingStateMachine })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of states) {
-                if (!sbSeen.has(sym.name)) {
-                    sbSeen.add(sym.name);
-                    sbItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind("state"),
-                        detail: "state",
-                    });
-                }
-            }
+            appendSymbolsOfKinds(sbItems, sbSeen, symbolIndex, reachableFiles, {
+                kinds: ["state"],
+                container: info.enclosingStateMachine,
+            });
         }
+        appendSnippetsForScope(sbItems, sbSeen, "state_body", snippetSupport);
         return sbItems;
     }
     // Trait SM op contexts are symbol-only — no keywords or operators.
@@ -617,21 +604,209 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
     if (symbolKinds === "trace_method" && info.enclosingClass) {
         const items = [];
         const seen = new Set();
-        const symbols = symbolIndex
-            .getSymbols({ kind: "method", container: info.enclosingClass, inherited: true })
+        appendSymbolsOfKinds(items, seen, symbolIndex, reachableFiles, {
+            kinds: ["method"],
+            container: info.enclosingClass,
+            inherited: true,
+        });
+        return items;
+    }
+    if (symbolKinds === "trace_event" && info.enclosingClass) {
+        const items = [];
+        const seen = new Set();
+        appendSymbolsOfKinds(items, seen, symbolIndex, reachableFiles, {
+            kinds: ["event"],
+            container: info.enclosingClass,
+            inherited: true,
+        });
+        return items;
+    }
+    // Topic 052 item 2 — `before |` / `after |` / `before p|` / `after p|`
+    // code-injection slot. Method symbols of the enclosing class with
+    // inheritance, no built-ins, no LookaheadIterator keywords. Same shape
+    // as trace_method but kept on a distinct scalar for semantic clarity
+    // (and to leave room for `around` etc. later).
+    if (symbolKinds === "code_injection_method" && info.enclosingClass) {
+        const items = [];
+        const seen = new Set();
+        appendSymbolsOfKinds(items, seen, symbolIndex, reachableFiles, {
+            kinds: ["method"],
+            container: info.enclosingClass,
+            inherited: true,
+        });
+        return items;
+    }
+    // Topic 052 item 3 — `filter { include ... }` class-target slot. Class
+    // symbols only — no built-ins, no `void`, no LookaheadIterator
+    // keywords. Covers blank `include |` and typed `include S|`.
+    if (symbolKinds === "filter_include_target") {
+        const items = [];
+        const seen = new Set();
+        appendSymbolsOfKinds(items, seen, symbolIndex, reachableFiles, {
+            kinds: ["class"],
+        });
+        return items;
+    }
+    // Topic 055 — `class C { sm name as |` (referenced_statemachine target).
+    // Offer SMs valid for class-local reuse: class-local statemachines from the
+    // enclosing class plus top-level standalone statemachine_definitions
+    // reachable from this file. No keywords, operators, types.
+    if (symbolKinds === "referenced_sm_target") {
+        const items = [];
+        const seen = new Set();
+        if (info.enclosingClass) {
+            // Class-local SMs use the convention `<className>.<smName>` for their
+            // container; symbol container === `${enclosingClass}.${name}`.
+            const local = symbolIndex
+                .getSymbols({ kind: "statemachine" })
+                .filter((s) => s.container === `${info.enclosingClass}.${s.name}`)
+                .filter((s) => reachableFiles.has(path.normalize(s.file)));
+            for (const sym of local) {
+                if (!seen.has(sym.name)) {
+                    seen.add(sym.name);
+                    items.push({
+                        label: sym.name,
+                        kind: symbolKindToCompletionKind("statemachine"),
+                        detail: "statemachine",
+                    });
+                }
+            }
+        }
+        // Top-level standalone statemachines: container === name (no class prefix).
+        const topLevel = symbolIndex
+            .getSymbols({ kind: "statemachine" })
+            .filter((s) => s.container === s.name)
             .filter((s) => reachableFiles.has(path.normalize(s.file)));
-        for (const sym of symbols) {
+        for (const sym of topLevel) {
+            if (!seen.has(sym.name)) {
+                seen.add(sym.name);
+                items.push({
+                    label: sym.name,
+                    kind: symbolKindToCompletionKind("statemachine"),
+                    detail: "top-level statemachine",
+                });
+            }
+        }
+        return items;
+    }
+    // Topic 055 — `isA T<sm as |...` first-segment slot. Same SM universe as
+    // referenced_sm_target but kept separate so future divergence (e.g., trait
+    // type parameter constraints) is easy to contain.
+    if (symbolKinds === "trait_sm_binding_target") {
+        const items = [];
+        const seen = new Set();
+        if (info.enclosingClass) {
+            const local = symbolIndex
+                .getSymbols({ kind: "statemachine" })
+                .filter((s) => s.container === `${info.enclosingClass}.${s.name}`)
+                .filter((s) => reachableFiles.has(path.normalize(s.file)));
+            for (const sym of local) {
+                if (!seen.has(sym.name)) {
+                    seen.add(sym.name);
+                    items.push({
+                        label: sym.name,
+                        kind: symbolKindToCompletionKind("statemachine"),
+                        detail: "statemachine",
+                    });
+                }
+            }
+        }
+        const topLevel = symbolIndex
+            .getSymbols({ kind: "statemachine" })
+            .filter((s) => s.container === s.name)
+            .filter((s) => reachableFiles.has(path.normalize(s.file)));
+        for (const sym of topLevel) {
             if (!seen.has(sym.name)) {
                 seen.add(sym.name);
-                items.push({ label: sym.name, kind: symbolKindToCompletionKind("method"), detail: "method" });
+                items.push({
+                    label: sym.name,
+                    kind: symbolKindToCompletionKind("statemachine"),
+                    detail: "top-level statemachine",
+                });
             }
         }
         return items;
     }
+    // Topic 055 — `isA T<sm as <smName>(.<seg>)*.|...` dotted-state continuation.
+    // The analyzer captures (smName, statePrefix) from the in-progress
+    // qualified_name. Resolve smContainer as class-local first
+    // (`${enclosingClass}.${smName}`), falling back to the top-level standalone
+    // statemachine container (`${smName}` self-container). When the state
+    // prefix is empty, offer depth-1 states of the SM root; otherwise descend
+    // via `getChildStateNames` so nested paths like `Sm.S1.|` surface S1's
+    // direct children.
+    if (symbolKinds === "trait_sm_binding_state_target") {
+        const items = [];
+        const seen = new Set();
+        const enclosingClass = info.enclosingClass;
+        const smName = info.traitSmBindingSmName;
+        const statePrefix = info.traitSmBindingStatePrefix ?? [];
+        if (smName) {
+            const candidates = [];
+            if (enclosingClass)
+                candidates.push(`${enclosingClass}.${smName}`);
+            candidates.push(smName); // top-level standalone fallback
+            let smContainer;
+            for (const cand of candidates) {
+                const exists = symbolIndex
+                    .getSymbols({ container: cand, kind: "statemachine", name: smName })
+                    .some((s) => reachableFiles.has(path.normalize(s.file)));
+                if (exists) {
+                    smContainer = cand;
+                    break;
+                }
+            }
+            if (smContainer) {
+                if (statePrefix.length === 0) {
+                    // Top-level states of the SM (depth 1).
+                    const directStates = symbolIndex
+                        .getSymbols({ container: smContainer, kind: "state" })
+                        .filter((s) => reachableFiles.has(path.normalize(s.file)))
+                        .filter((s) => (s.statePath?.length ?? 0) === 1);
+                    for (const sym of directStates) {
+                        if (!seen.has(sym.name)) {
+                            seen.add(sym.name);
+                            items.push({
+                                label: sym.name,
+                                kind: symbolKindToCompletionKind("state"),
+                                detail: "state",
+                            });
+                        }
+                    }
+                }
+                else {
+                    // Nested states under the prefix (e.g., Sm.S1.|).
+                    const childNames = symbolIndex.getChildStateNames(statePrefix, smContainer, reachableFiles);
+                    for (const name of childNames) {
+                        if (!seen.has(name)) {
+                            seen.add(name);
+                            items.push({
+                                label: name,
+                                kind: symbolKindToCompletionKind("state"),
+                                detail: "state",
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return items;
+    }
+    // Topic 052 item 4 — method parameter-type slot. Built-ins (excluding
+    // `void`) + class / interface / trait / enum. Same shape as
+    // decl_type_typed_prefix but on a distinct scalar so divergence is
+    // contained.
+    if (symbolKinds === "param_type_typed_prefix") {
+        return buildTypeCompletionItems(symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait", "enum"],
+            includeBuiltins: true,
+            excludeVoid: true,
+        });
+    }
     if (symbolKinds === "trace_state_method" && info.enclosingClass) {
         const items = [];
         const seen = new Set();
-        // States from all SMs in the enclosing class
+        // States from all SMs in the enclosing class — pattern C, specialized.
         const states = symbolIndex
             .getSymbols({ kind: "state" })
             .filter((s) => s.container?.startsWith(info.enclosingClass + "."))
@@ -643,37 +818,42 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
             }
         }
         // Methods from the enclosing class
-        const methods = symbolIndex
-            .getSymbols({ kind: "method", container: info.enclosingClass, inherited: true })
-            .filter((s) => reachableFiles.has(path.normalize(s.file)));
-        for (const sym of methods) {
-            if (!seen.has(sym.name)) {
-                seen.add(sym.name);
-                items.push({ label: sym.name, kind: symbolKindToCompletionKind("method"), detail: "method" });
-            }
-        }
+        appendSymbolsOfKinds(items, seen, symbolIndex, reachableFiles, {
+            kinds: ["method"],
+            container: info.enclosingClass,
+            inherited: true,
+        });
         return items;
     }
     if (symbolKinds === "trace_attribute" && info.enclosingClass) {
         const items = [];
         const seen = new Set();
-        const symbols = symbolIndex
-            .getSymbols({ kind: "attribute", container: info.enclosingClass, inherited: true })
-            .filter((s) => reachableFiles.has(path.normalize(s.file)));
-        for (const sym of symbols) {
-            if (!seen.has(sym.name)) {
-                seen.add(sym.name);
-                items.push({ label: sym.name, kind: symbolKindToCompletionKind("attribute"), detail: "attribute" });
-            }
-        }
+        appendSymbolsOfKinds(items, seen, symbolIndex, reachableFiles, {
+            kinds: ["attribute"],
+            container: info.enclosingClass,
+            inherited: true,
+        });
         return items;
     }
     // Structured userStory body — curated tag starters only.
     if (symbolKinds === "userstory_body") {
-        return USER_STORY_BODY_STARTERS.map((kw) => ({
+        const usItems = USER_STORY_BODY_STARTERS.map((kw) => ({
             label: kw,
             kind: node_1.CompletionItemKind.Keyword,
         }));
+        const usSeen = new Set(USER_STORY_BODY_STARTERS);
+        appendSnippetsForScope(usItems, usSeen, "userstory_body", snippetSupport);
+        return usItems;
+    }
+    // Partial inline association — arrow slot after the left multiplicity
+    // (e.g. `1 |`, `1 -|`, `1 <|`). Curated arrow operators only — no
+    // multiplicity, no type symbols, no class-body keywords.
+    if (symbolKinds === "association_arrow") {
+        return ASSOCIATION_ARROW_STARTERS.map((a) => ({
+            label: a,
+            kind: node_1.CompletionItemKind.Operator,
+            detail: "association arrow",
+        }));
     }
     // Partial inline association — right-multiplicity slot after the arrow
     // (e.g. `1 -> |`). Curated multiplicities only; no class-body junk.
@@ -687,22 +867,9 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
     // Partial inline association — right-type slot after the right multiplicity
     // (e.g. `1 -> * |`). Offer class symbols only, no keywords.
     if (symbolKinds === "association_type") {
-        const atItems = [];
-        const atSeen = new Set();
-        const classes = symbolIndex
-            .getSymbols({ kind: "class" })
-            .filter((s) => reachableFiles.has(path.normalize(s.file)));
-        for (const sym of classes) {
-            if (!atSeen.has(sym.name)) {
-                atSeen.add(sym.name);
-                atItems.push({
-                    label: sym.name,
-                    kind: symbolKindToCompletionKind("class"),
-                    detail: "class",
-                });
-            }
-        }
-        return atItems;
+        return buildTypeCompletionItems(symbolIndex, reachableFiles, {
+            kinds: ["class"],
+        });
     }
     // Typed-prefix on the right_type identifier (e.g. `1 -> * O|`). Once the
     // parser commits to a complete `association_inline` / `association_member`,
@@ -710,31 +877,54 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
     // raw LookaheadIterator keyword junk; this narrower scope returns just the
     // legitimate type symbols (class / interface / trait) without keywords.
     if (symbolKinds === "association_typed_prefix") {
-        const atItems = [];
-        const atSeen = new Set();
-        for (const symKind of ["class", "interface", "trait"]) {
-            const symbols = symbolIndex
-                .getSymbols({ kind: symKind })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of symbols) {
-                if (!atSeen.has(sym.name)) {
-                    atSeen.add(sym.name);
-                    atItems.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(symKind),
-                        detail: symKind,
-                    });
-                }
-            }
-        }
-        return atItems;
+        return buildTypeCompletionItems(symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait"],
+        });
+    }
+    // Typed-prefix on the isa_declaration type identifier (topic 047 item 1).
+    // Same motivation as association_typed_prefix above: the generic
+    // (isa_declaration) @scope.class_interface_trait capture pulls in raw
+    // LookaheadIterator keyword junk when recovering from incomplete parses.
+    // This narrower scope returns only class / interface / trait symbols.
+    if (symbolKinds === "isa_typed_prefix") {
+        return buildTypeCompletionItems(symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait"],
+        });
+    }
+    // Typed-prefix on attribute/const declaration type identifier (topic 047
+    // item 2). Cursor sits inside a type_name under attribute_declaration or
+    // const_declaration. Default class_body scope leaks 54+ LookaheadIterator
+    // keywords (test, generic, class, isA, trace, ...) and surfaces zero type
+    // symbols. Symbol-only early-return: built-in types + class / interface /
+    // trait / enum. `void` is deliberately excluded — method-return only.
+    if (symbolKinds === "decl_type_typed_prefix") {
+        return buildTypeCompletionItems(symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait", "enum"],
+            includeBuiltins: true,
+            excludeVoid: true,
+        });
+    }
+    // Typed-prefix on method return-type identifier (topic 047 item 3).
+    // Same shape as decl_type_typed_prefix, but fires on method_declaration /
+    // abstract_method_declaration / method_signature / trait_method_signature
+    // and KEEPS `void`. Parameter types sit under `param` (not a method rule)
+    // and are excluded by detection, so they fall through to the class_body
+    // path and remain untouched by this branch.
+    if (symbolKinds === "return_type_typed_prefix") {
+        return buildTypeCompletionItems(symbolIndex, reachableFiles, {
+            kinds: ["class", "interface", "trait", "enum"],
+            includeBuiltins: true,
+        });
     }
     // Structured useCase body — userStoryTags plus useCaseStep starters.
     if (symbolKinds === "usecase_body") {
-        return USE_CASE_BODY_STARTERS.map((kw) => ({
+        const ucItems = USE_CASE_BODY_STARTERS.map((kw) => ({
             label: kw,
             kind: node_1.CompletionItemKind.Keyword,
         }));
+        const ucSeen = new Set(USE_CASE_BODY_STARTERS);
+        appendSnippetsForScope(ucItems, ucSeen, "usecase_body", snippetSupport);
+        return ucItems;
     }
     // implementsReq scope — symbol-only, no keywords/operators. The req_implementation
     // grammar rule only permits `implementsReq <id>(, <id>)* ;`, so surfacing class /
@@ -757,33 +947,42 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
         }
         return reqItems;
     }
-    // 1. Keywords from LookaheadIterator (filtered in constraint contexts)
-    let keywords = info.keywords;
-    if (symbolKinds === "own_attribute" ||
-        symbolKinds === "guard_attribute_method" ||
-        symbolKinds === "trace_attribute_method" ||
-        symbolKinds === "sorted_attribute") {
-        keywords = keywords.filter((kw) => !CONSTRAINT_BLOCKLIST.has(kw));
-    }
-    for (const kw of keywords) {
+    // Every specialized / curated scope has early-returned above. Everything
+    // else falls through to the raw-lookahead path — it is the ONLY place in
+    // this builder where `info.keywords` (LookaheadIterator output) reaches
+    // the user. See `buildLookaheadFallbackItems` for the contract.
+    return buildLookaheadFallbackItems(info, symbolKinds, symbolIndex, reachableFiles);
+}
+/**
+ * The raw-lookahead fallback path for `buildSemanticCompletionItems`.
+ *
+ * After topic 049 phase 2 this is reached only when `symbolKinds` is an
+ * array (`SymbolKind[]`) — every scalar scope has its own early-return
+ * branch above. This is the ONLY place in the builder where raw
+ * `info.keywords` (LookaheadIterator output) is surfaced to the user, and
+ * it is now array-only: no scalar scope surfaces raw lookahead anywhere.
+ *
+ * If you add a new scalar scope, route it via an early-return in
+ * `buildSemanticCompletionItems`, not through this path.
+ */
+function buildLookaheadFallbackItems(info, symbolKinds, symbolIndex, reachableFiles) {
+    const items = [];
+    const seen = new Set();
+    // 1. Keywords from LookaheadIterator.
+    for (const kw of info.keywords) {
         if (!seen.has(kw)) {
             seen.add(kw);
             items.push({ label: kw, kind: node_1.CompletionItemKind.Keyword });
         }
     }
-    // 2. Operators (skip in guard/constraint/trace contexts)
-    if (symbolKinds !== "own_attribute" &&
-        symbolKinds !== "guard_attribute_method" &&
-        symbolKinds !== "trace_attribute_method" &&
-        symbolKinds !== "sorted_attribute") {
-        for (const op of info.operators) {
-            if (!seen.has(op)) {
-                seen.add(op);
-                items.push({ label: op, kind: node_1.CompletionItemKind.Operator });
-            }
+    // 2. Operators.
+    for (const op of info.operators) {
+        if (!seen.has(op)) {
+            seen.add(op);
+            items.push({ label: op, kind: node_1.CompletionItemKind.Operator });
         }
     }
-    // 3. Built-in types (when in type-compatible scope)
+    // 3. Built-in types (when in type-compatible scope).
     if (Array.isArray(symbolKinds) &&
         symbolKinds.some((k) => ["class", "interface", "trait", "enum"].includes(k))) {
         for (const typ of keywords_1.BUILTIN_TYPES) {
@@ -797,62 +996,7 @@ function buildSemanticCompletionItems(info, symbolKinds, symbolIndex, reachableF
             }
         }
     }
-    // 4. Constraint scope: only own attributes (Umple E28)
-    if (symbolKinds === "own_attribute" && info.enclosingClass) {
-        const symbols = symbolIndex
-            .getSymbols({ container: info.enclosingClass, kind: "attribute" })
-            .filter((s) => reachableFiles.has(path.normalize(s.file)));
-        for (const sym of symbols) {
-            if (!seen.has(sym.name)) {
-                seen.add(sym.name);
-                items.push({
-                    label: sym.name,
-                    kind: symbolKindToCompletionKind("attribute"),
-                    detail: "attribute",
-                });
-            }
-        }
-        return items;
-    }
-    // 5. Sorted key scope: attributes of the owner class (with inheritance)
-    if (symbolKinds === "sorted_attribute" && info.sortedKeyOwner) {
-        const symbols = symbolIndex
-            .getSymbols({ container: info.sortedKeyOwner, kind: "attribute", inherited: true })
-            .filter((s) => reachableFiles.has(path.normalize(s.file)));
-        for (const sym of symbols) {
-            if (!seen.has(sym.name)) {
-                seen.add(sym.name);
-                items.push({
-                    label: sym.name,
-                    kind: symbolKindToCompletionKind("attribute"),
-                    detail: "attribute",
-                });
-            }
-        }
-        return items;
-    }
-    // 6. Guard/trace scope: attributes + methods from enclosing class (with inheritance)
-    if ((symbolKinds === "guard_attribute_method" ||
-        symbolKinds === "trace_attribute_method") &&
-        info.enclosingClass) {
-        for (const kind of ["attribute", "method"]) {
-            const symbols = symbolIndex
-                .getSymbols({ container: info.enclosingClass, kind, inherited: true })
-                .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            for (const sym of symbols) {
-                if (!seen.has(sym.name)) {
-                    seen.add(sym.name);
-                    items.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(kind),
-                        detail: kind,
-                    });
-                }
-            }
-        }
-        return items;
-    }
-    // 6. Symbol completions from index (scoped to reachable files)
+    // 4. Symbol completions from index (scoped to reachable files).
     if (Array.isArray(symbolKinds)) {
         for (const symKind of symbolKinds) {
             let symbols;