sysml-v2-lsp 0.37.0 → 0.39.0

package/dist/server/mcpServer.js

@@ -159214,12 +159214,19 @@ var MAX_NAMESPACE_NESTING_DEPTH = 64;
 function findConflictedQualifiedNames(allSymbols) {
   return groupConflicts(allSymbols.filter((s) => s.qualifiedName !== void 0), (s) => s.qualifiedName);
 }
+function memberNamesOf(symbol2) {
+  return symbol2.shortName && symbol2.shortName !== symbol2.name ? [symbol2.name, symbol2.shortName] : [symbol2.name];
+}
 function findConflictingDeclarations(allSymbols) {
   const conflicting = /* @__PURE__ */ new Map();
   const add = (groups) => {
-    for (const group of groups.values()) for (const s of group) conflicting.set(s, group);
+    for (const group of groups) {
+      for (const s of group) {
+        conflicting.set(s, [.../* @__PURE__ */ new Set([...conflicting.get(s) ?? [], ...group])]);
+      }
+    }
   };
-  add(findConflictedQualifiedNames(allSymbols));
+  add(findConflictedQualifiedNames(allSymbols).values());
   const membersOfAnonymous = allSymbols.filter((s) => s.qualifiedName === void 0 && !isAnonymous(s) && s.parentId !== void 0);
   const byOwner = /* @__PURE__ */ new Map();
   for (const s of membersOfAnonymous) {
@@ -159227,13 +159234,33 @@ function findConflictingDeclarations(allSymbols) {
     list.push(s);
     byOwner.set(s.parentId, list);
   }
-  for (const members2 of byOwner.values()) add(groupConflicts(members2, (s) => s.name));
+  for (const members2 of byOwner.values()) add(groupConflicts(members2, (s) => s.name).values());
+  add([...findConflictingShortNames(allSymbols).values()].map((group) => group.symbols));
   return conflicting;
 }
+function findConflictingShortNames(allSymbols) {
+  const byId = new Map(allSymbols.map((s) => [s.symbolId, s]));
+  const entries = [];
+  const keysWithShortName = /* @__PURE__ */ new Set();
+  for (const s of allSymbols) {
+    if (isAnonymous(s)) continue;
+    const owner = s.parentId ? byId.get(s.parentId) : void 0;
+    const namespace = owner === void 0 ? "q:" : owner.qualifiedName !== void 0 ? `q:${owner.qualifiedName}` : `id:${owner.symbolId}`;
+    for (const name of memberNamesOf(s)) {
+      const key = `${namespace}\0${name}`;
+      entries.push({ symbol: s, key });
+      if (name === s.shortName) keysWithShortName.add(key);
+    }
+  }
+  const groups = groupKeyedConflicts(entries.filter((e) => keysWithShortName.has(e.key)));
+  return new Map([...groups].map(([key, symbols]) => [key, { name: key.slice(key.indexOf("\0") + 1), symbols }]));
+}
 function groupConflicts(symbols, keyOf) {
+  return groupKeyedConflicts(symbols.map((symbol2) => ({ symbol: symbol2, key: keyOf(symbol2) })));
+}
+function groupKeyedConflicts(entries) {
   const byKeyAndKind = /* @__PURE__ */ new Map();
-  for (const s of symbols) {
-    const key = keyOf(s);
+  for (const { symbol: s, key } of entries) {
     let byKind = byKeyAndKind.get(key);
     if (!byKind) {
       byKind = /* @__PURE__ */ new Map();
@@ -159305,7 +159332,13 @@ function buildSymbolIndexes(allSymbols) {
   for (const s of allSymbols) {
     byId.set(s.symbolId, s);
   }
-  const indexes = { byName, byParent, byQualifiedName, byId, definitionsByName, portsByName };
+  const clashingShortNames = /* @__PURE__ */ new Map();
+  for (const { name, symbols } of findConflictingShortNames(allSymbols).values()) {
+    const clashing = clashingShortNames.get(name) ?? /* @__PURE__ */ new Set();
+    for (const s of symbols) clashing.add(s);
+    clashingShortNames.set(name, clashing);
+  }
+  const indexes = { byName, byParent, byQualifiedName, byId, definitionsByName, portsByName, clashingShortNames };
   for (const s of allSymbols) {
     if (isAnonymous(s)) continue;
     const nameList = byName.get(s.name) ?? [];
@@ -159394,6 +159427,16 @@ var NamespaceResolver = class {
   resolveNameIn(namespace, name, indexes) {
     return this.resolveQualifiedNameFrom(namespace ? namespaceKeyOf(namespace) : "", name, indexes);
   }
+  /** Resolve an editor reference without losing the reason a name is unresolved. */
+  resolveReferenceIn(namespace, name, indexes) {
+    return this.resolveQualifiedReferenceFrom(namespace ? namespaceKeyOf(namespace) : "", name, indexes);
+  }
+  /** Resolve a public qualified or feature-path member, without enclosing-scope fallback. */
+  resolveMemberReference(owner, name, indexes) {
+    const members2 = this.getResolvedMembers(namespaceKeyOf(owner), indexes).get(name);
+    if (members2 && this.isAmbiguous(name, members2, indexes)) return { ambiguous: true };
+    return this.referenceTo(members2?.find((member) => member.visibility === "public")?.symbol, indexes);
+  }
   /**
    * Resolve a (possibly qualified) name to its symbol per §7.5.1, searching
    * outward from namespace `start` and its enclosing namespaces (its own resolved
@@ -159405,28 +159448,48 @@ var NamespaceResolver = class {
    * its own enclosing package already imported, per §7.5.1/§7.5.3).
    */
   resolveQualifiedNameFrom(start, name, indexes) {
+    return this.resolveQualifiedReferenceFrom(start, name, indexes).symbol;
+  }
+  resolveQualifiedReferenceFrom(start, name, indexes) {
     const [first, ...rest] = splitQualifiedName(name);
     let resolved;
     for (const ancestor of this.namespaceAncestorsOf(start, indexes)) {
       const candidates = this.getResolvedMembers(ancestor, indexes).get(first);
       if (candidates && candidates.length > 0) {
+        if (this.isAmbiguous(first, candidates, indexes)) return { ambiguous: true };
         resolved = candidates[0].symbol;
         break;
       }
     }
-    if (resolved === void 0) return void 0;
+    if (resolved === void 0) return { ambiguous: false };
     const isWithinStart = (namespace) => this.namespaceAncestorsOf(start, indexes).has(namespace);
     for (const segment of rest) {
       const owner = resolved;
       const ownerKey = namespaceKeyOf(owner);
       const members2 = this.getResolvedMembers(ownerKey, indexes).get(segment);
+      if (members2 && this.isAmbiguous(segment, members2, indexes)) return { ambiguous: true };
       const visibleMember = members2?.find(
         (m2) => m2.visibility === "public" || isWithinStart(ownerKey) || m2.visibility === "protected" && this.isProtectedVisibleFrom(start, owner, indexes)
       );
-      if (!visibleMember) return void 0;
+      if (!visibleMember) return { ambiguous: false };
       resolved = visibleMember.symbol;
     }
-    return resolved.qualifiedName !== void 0 ? indexes.byQualifiedName.get(resolved.qualifiedName) : resolved;
+    return this.referenceTo(resolved, indexes);
+  }
+  referenceTo(resolved, indexes) {
+    if (!resolved) return { ambiguous: false };
+    const symbol2 = resolved.qualifiedName !== void 0 ? indexes.byQualifiedName.get(resolved.qualifiedName) : resolved;
+    return { symbol: symbol2, ambiguous: symbol2 === void 0 };
+  }
+  /**
+   * Whether `name` names more than one of `candidates` that clash on it
+   * through a short name (`SymbolIndexes.clashingShortNames`), so it can't
+   * be resolved to either (KerML 7.2.5.2). Like a conflicted qualifiedName,
+   * it doesn't fall through to an enclosing namespace's member of that name.
+   */
+  isAmbiguous(name, candidates, indexes) {
+    const clashing = indexes.clashingShortNames.get(name);
+    return clashing !== void 0 && candidates.filter((c) => clashing.has(c.symbol)).length > 1;
   }
   /**
    * §7.5.3's protected-import exception: "A visibility of protected is the