sysml-v2-lsp 0.38.0 → 0.39.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [0.39.0]
+
+### Fixed
+
+- A short name that clashes with a sibling's name or short name (`part def <A> Alpha; part def A;`) is reported as `ambiguous-namespace-name` (KerML 7.2.5.2), and a reference by the name they clash on (`A`) is left unresolved rather than taken for either.
+- Keep ambiguous names unresolved in navigation, hover, references, rename,
+  linked editing and hierarchy preparation, including qualified and feature paths.
+  Retain every conflicting declaration when both names of an element clash.
+
 ## [0.38.0]
 
 ### Added

package/dist/server/browserServerMain.js

@@ -136447,12 +136447,19 @@ ${JSON.stringify(message, null, 4)}`);
   function findConflictedQualifiedNames(allSymbols) {
     return groupConflicts(allSymbols.filter((s) => s.qualifiedName !== void 0), (s) => s.qualifiedName);
   }
+  function memberNamesOf(symbol) {
+    return symbol.shortName && symbol.shortName !== symbol.name ? [symbol.name, symbol.shortName] : [symbol.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) {
@@ -136460,13 +136467,33 @@ ${JSON.stringify(message, null, 4)}`);
       list.push(s);
       byOwner.set(s.parentId, list);
     }
-    for (const members of byOwner.values()) add(groupConflicts(members, (s) => s.name));
+    for (const members of byOwner.values()) add(groupConflicts(members, (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((symbol) => ({ symbol, key: keyOf(symbol) })));
+  }
+  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();
@@ -136538,7 +136565,13 @@ ${JSON.stringify(message, null, 4)}`);
     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) ?? [];
@@ -136627,6 +136660,16 @@ ${JSON.stringify(message, null, 4)}`);
     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 members = this.getResolvedMembers(namespaceKeyOf(owner), indexes).get(name);
+      if (members && this.isAmbiguous(name, members, indexes)) return { ambiguous: true };
+      return this.referenceTo(members?.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
@@ -136638,28 +136681,48 @@ ${JSON.stringify(message, null, 4)}`);
      * 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 members = this.getResolvedMembers(ownerKey, indexes).get(segment);
+        if (members && this.isAmbiguous(segment, members, indexes)) return { ambiguous: true };
         const visibleMember = members?.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 symbol = resolved.qualifiedName !== void 0 ? indexes.byQualifiedName.get(resolved.qualifiedName) : resolved;
+      return { symbol, ambiguous: symbol === 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
@@ -139365,9 +139428,11 @@ ${childIndent}item def ${sourceName};
         if (target && !path.qualifiedNames.some((name) => name.segments.some((segment) => segment.name === target.name || segment.name === target.shortName))) continue;
         const namespace = namespaces.find((ns) => ns.body < path.start && path.end <= ns.end);
         let receiver;
+        let receiverAmbiguous = false;
         for (let group = 0; group < path.qualifiedNames.length; group++) {
           const qualified = path.qualifiedNames[group];
           let resolved;
+          let ambiguous = false;
           for (let index2 = 0; index2 < qualified.segments.length; index2++) {
             const segment = qualified.segments[index2];
             const range = import_node3.Range.create(doc.positionAt(segment.start), doc.positionAt(segment.end));
@@ -139376,17 +139441,27 @@ ${childIndent}item def ${sourceName};
             while (before >= 0 && /\s/.test(text[before])) before--;
             while (after < text.length && /\s/.test(text[after])) after++;
             const declaration = symbols.find((symbol) => !isAnonymous(symbol) && (symbol.selectionRange.start.line === range.start.line && symbol.selectionRange.start.character === range.start.character && symbol.selectionRange.end.character === range.end.character || symbol.shortName === segment.name && text[before] === "<" && text[after] === ">" && doc.offsetAt(symbol.range.start) <= segment.start && segment.end < doc.offsetAt(symbol.selectionRange.start)));
-            if (declaration) resolved = declaration;
-            else if (index2 > 0) {
-              resolved = resolved ? this.resolver.getResolvedMembers(namespaceKeyOf(resolved), this.indexes).get(segment.name)?.find((entry) => entry.visibility === "public")?.symbol : void 0;
+            if (declaration) {
+              resolved = declaration;
+              ambiguous = false;
+            } else if (index2 > 0) {
+              if (resolved) {
+                const result = this.resolver.resolveMemberReference(resolved, segment.name, this.indexes);
+                resolved = result.symbol;
+                ambiguous = result.ambiguous;
+              }
             } else if (group > 0) {
-              resolved = receiver ? this.resolveFeature(receiver, segment.name) : void 0;
+              const result = receiver ? this.resolveFeature(receiver, segment.name) : { ambiguous: receiverAmbiguous };
+              resolved = result.symbol;
+              ambiguous = result.ambiguous;
             } else {
-              resolved = this.resolver.resolveNameIn(
+              const result = this.resolver.resolveReferenceIn(
                 namespace?.symbol,
                 joinQualifiedName([segment.name]),
                 this.indexes
               );
+              resolved = result.symbol;
+              ambiguous = result.ambiguous;
             }
             if (cursor !== void 0 && (cursor < segment.start || cursor > segment.end)) continue;
             if (target && segment.name !== target.name && segment.name !== target.shortName) continue;
@@ -139396,10 +139471,12 @@ ${childIndent}item def ${sourceName};
               name: segment.name,
               qualifiedName: index2 === qualified.segments.length - 1 ? qualified.name : segment.name,
               symbol: resolved,
-              isDeclaration: declaration !== void 0
+              isDeclaration: declaration !== void 0,
+              isAmbiguous: ambiguous
             });
           }
           receiver = resolved;
+          receiverAmbiguous = ambiguous;
         }
       }
       return refs;
@@ -139411,14 +139488,14 @@ ${childIndent}item def ${sourceName};
         const owner = queue[index2];
         if (visited.has(owner)) continue;
         visited.add(owner);
-        const member = this.resolver.getResolvedMembers(namespaceKeyOf(owner), this.indexes).get(name)?.find((entry) => entry.visibility === "public")?.symbol;
-        if (member) return member;
+        const member = this.resolver.resolveMemberReference(owner, name, this.indexes);
+        if (member.symbol || member.ambiguous) return member;
         for (const typeName of owner.typeNames) {
           const type = this.resolver.resolveNameFrom(owner, typeName, this.indexes);
           if (type && !visited.has(type)) queue.push(type);
         }
       }
-      return void 0;
+      return { ambiguous: false };
     }
   };
 
@@ -139435,6 +139512,7 @@ ${childIndent}item def ${sourceName};
       }
       const wsSymbolTable = this.documentManager.getWorkspaceSymbolTable();
       const reference = new NameReferences(this.documentManager).at(params.textDocument.uri, params.position);
+      if (reference?.isAmbiguous) return null;
       if (reference?.symbol && !reference.isDeclaration) {
         return { uri: reference.symbol.uri, range: reference.symbol.selectionRange };
       }
@@ -140049,6 +140127,7 @@ ${childIndent}item def ${sourceName};
       }
       const text = this.documentManager.getText(params.textDocument.uri);
       const reference = new NameReferences(this.documentManager).at(params.textDocument.uri, params.position);
+      if (reference?.isAmbiguous) return null;
       const word = reference?.qualifiedName ?? (text ? this.getWordAtPosition(text, params.position.line, params.position.character) : void 0);
       if (word && word.includes("::") && !reference?.symbol) {
         const libHover = this.buildLibraryHover(word);

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

package/dist/server/server.js

@@ -125418,12 +125418,19 @@ var MAX_NAMESPACE_NESTING_DEPTH = 64;
 function findConflictedQualifiedNames(allSymbols) {
   return groupConflicts(allSymbols.filter((s) => s.qualifiedName !== void 0), (s) => s.qualifiedName);
 }
+function memberNamesOf(symbol) {
+  return symbol.shortName && symbol.shortName !== symbol.name ? [symbol.name, symbol.shortName] : [symbol.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) {
@@ -125431,13 +125438,33 @@ function findConflictingDeclarations(allSymbols) {
     list.push(s);
     byOwner.set(s.parentId, list);
   }
-  for (const members of byOwner.values()) add(groupConflicts(members, (s) => s.name));
+  for (const members of byOwner.values()) add(groupConflicts(members, (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((symbol) => ({ symbol, key: keyOf(symbol) })));
+}
+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();
@@ -125509,7 +125536,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) ?? [];
@@ -125598,6 +125631,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 members = this.getResolvedMembers(namespaceKeyOf(owner), indexes).get(name);
+    if (members && this.isAmbiguous(name, members, indexes)) return { ambiguous: true };
+    return this.referenceTo(members?.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
@@ -125609,28 +125652,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 members = this.getResolvedMembers(ownerKey, indexes).get(segment);
+      if (members && this.isAmbiguous(segment, members, indexes)) return { ambiguous: true };
       const visibleMember = members?.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 symbol = resolved.qualifiedName !== void 0 ? indexes.byQualifiedName.get(resolved.qualifiedName) : resolved;
+    return { symbol, ambiguous: symbol === 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
@@ -128333,9 +128396,11 @@ var NameReferences = class {
       if (target && !path3.qualifiedNames.some((name) => name.segments.some((segment) => segment.name === target.name || segment.name === target.shortName))) continue;
       const namespace = namespaces.find((ns) => ns.body < path3.start && path3.end <= ns.end);
       let receiver;
+      let receiverAmbiguous = false;
       for (let group = 0; group < path3.qualifiedNames.length; group++) {
         const qualified = path3.qualifiedNames[group];
         let resolved;
+        let ambiguous = false;
         for (let index2 = 0; index2 < qualified.segments.length; index2++) {
           const segment = qualified.segments[index2];
           const range = import_node4.Range.create(doc.positionAt(segment.start), doc.positionAt(segment.end));
@@ -128344,17 +128409,27 @@ var NameReferences = class {
           while (before >= 0 && /\s/.test(text[before])) before--;
           while (after < text.length && /\s/.test(text[after])) after++;
           const declaration = symbols.find((symbol) => !isAnonymous(symbol) && (symbol.selectionRange.start.line === range.start.line && symbol.selectionRange.start.character === range.start.character && symbol.selectionRange.end.character === range.end.character || symbol.shortName === segment.name && text[before] === "<" && text[after] === ">" && doc.offsetAt(symbol.range.start) <= segment.start && segment.end < doc.offsetAt(symbol.selectionRange.start)));
-          if (declaration) resolved = declaration;
-          else if (index2 > 0) {
-            resolved = resolved ? this.resolver.getResolvedMembers(namespaceKeyOf(resolved), this.indexes).get(segment.name)?.find((entry) => entry.visibility === "public")?.symbol : void 0;
+          if (declaration) {
+            resolved = declaration;
+            ambiguous = false;
+          } else if (index2 > 0) {
+            if (resolved) {
+              const result = this.resolver.resolveMemberReference(resolved, segment.name, this.indexes);
+              resolved = result.symbol;
+              ambiguous = result.ambiguous;
+            }
           } else if (group > 0) {
-            resolved = receiver ? this.resolveFeature(receiver, segment.name) : void 0;
+            const result = receiver ? this.resolveFeature(receiver, segment.name) : { ambiguous: receiverAmbiguous };
+            resolved = result.symbol;
+            ambiguous = result.ambiguous;
           } else {
-            resolved = this.resolver.resolveNameIn(
+            const result = this.resolver.resolveReferenceIn(
               namespace?.symbol,
               joinQualifiedName([segment.name]),
               this.indexes
             );
+            resolved = result.symbol;
+            ambiguous = result.ambiguous;
           }
           if (cursor !== void 0 && (cursor < segment.start || cursor > segment.end)) continue;
           if (target && segment.name !== target.name && segment.name !== target.shortName) continue;
@@ -128364,10 +128439,12 @@ var NameReferences = class {
             name: segment.name,
             qualifiedName: index2 === qualified.segments.length - 1 ? qualified.name : segment.name,
             symbol: resolved,
-            isDeclaration: declaration !== void 0
+            isDeclaration: declaration !== void 0,
+            isAmbiguous: ambiguous
           });
         }
         receiver = resolved;
+        receiverAmbiguous = ambiguous;
       }
     }
     return refs;
@@ -128379,14 +128456,14 @@ var NameReferences = class {
       const owner = queue[index2];
       if (visited.has(owner)) continue;
       visited.add(owner);
-      const member = this.resolver.getResolvedMembers(namespaceKeyOf(owner), this.indexes).get(name)?.find((entry) => entry.visibility === "public")?.symbol;
-      if (member) return member;
+      const member = this.resolver.resolveMemberReference(owner, name, this.indexes);
+      if (member.symbol || member.ambiguous) return member;
       for (const typeName of owner.typeNames) {
         const type = this.resolver.resolveNameFrom(owner, typeName, this.indexes);
         if (type && !visited.has(type)) queue.push(type);
       }
     }
-    return void 0;
+    return { ambiguous: false };
   }
 };
 
@@ -128403,6 +128480,7 @@ var DefinitionProvider = class {
     }
     const wsSymbolTable = this.documentManager.getWorkspaceSymbolTable();
     const reference = new NameReferences(this.documentManager).at(params.textDocument.uri, params.position);
+    if (reference?.isAmbiguous) return null;
     if (reference?.symbol && !reference.isDeclaration) {
       return { uri: reference.symbol.uri, range: reference.symbol.selectionRange };
     }
@@ -129017,6 +129095,7 @@ var HoverProvider = class {
     }
     const text = this.documentManager.getText(params.textDocument.uri);
     const reference = new NameReferences(this.documentManager).at(params.textDocument.uri, params.position);
+    if (reference?.isAmbiguous) return null;
     const word = reference?.qualifiedName ?? (text ? this.getWordAtPosition(text, params.position.line, params.position.character) : void 0);
     if (word && word.includes("::") && !reference?.symbol) {
       const libHover = this.buildLibraryHover(word);

package/package.json

@@ -2,7 +2,7 @@
   "name": "sysml-v2-lsp",
   "displayName": "SysML v2 Language Server",
   "description": "Language Server Protocol implementation for SysML v2, powered by ANTLR4",
-  "version": "0.38.0",
+  "version": "0.39.0",
   "publisher": "JamieD",
   "license": "MIT",
   "repository": {