sysml-v2-lsp 0.35.0 → 0.36.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.36.0]
+
+### Fixed
+
+- `incompatible-port-types` resolves each end of a `connect` through the features its path names (`a.p.q`), not by the port's name alone. Feature types and their supertypes are resolved in their declaring namespace, so unrelated same-named definitions cannot hide a real mismatch. When two parts each had a port of the same name, the first one declared stood in for both, causing false warnings or missed mismatches. An unresolved path still falls back to the name when only one port has it (#135).
+- A colon, `:>`, `{` or keyword inside a quoted name is no longer read as part of a declaration: `package 'Structure: System Context'` was typed `System` and reported as `unresolved-type`, and `part def 'Unit: Main'` was typed `Main`. Type and specialization fallback extraction masks the declaration's lexer `STRING` tokens, without scanning documentation or nested members, avoiding quadratic regex backtracking on quote-heavy comments (#134).
+- Visit each specialization ancestor only once when resolving inherited constraint features, preventing exponential queue growth through layered diamond inheritance (#127).
+- Hide implicitly redefined requirement subjects according to the declaring requirement's specialization ancestors, including redundant direct bases in multiple inheritance, while preserving subjects from unrelated branches.
+- Display decoded filesystem paths in workspace-folder logs and clarify that
+  element ID namespaces are used locally, without network access. Emit this
+  internal namespace information at debug level instead of info.
+
 ## [0.35.0]
 
 ### Added

package/dist/server/browserServerMain.js

@@ -3362,7 +3362,7 @@ ${JSON.stringify(message, null, 4)}`);
         }
         uinteger3.is = is;
       })(uinteger || (uinteger = {}));
-      (function(Position4) {
+      (function(Position5) {
         function create(line, character) {
           if (line === Number.MAX_VALUE) {
             line = uinteger.MAX_VALUE;
@@ -3372,14 +3372,14 @@ ${JSON.stringify(message, null, 4)}`);
           }
           return { line, character };
         }
-        Position4.create = create;
+        Position5.create = create;
         function is(value) {
           const candidate = value;
           return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
         }
-        Position4.is = is;
+        Position5.is = is;
       })(Position || (Position = {}));
-      (function(Range4) {
+      (function(Range5) {
         function create(one, two, three, four) {
           if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
             return { start: Position.create(one, two), end: Position.create(three, four) };
@@ -3389,12 +3389,12 @@ ${JSON.stringify(message, null, 4)}`);
             throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
           }
         }
-        Range4.create = create;
+        Range5.create = create;
         function is(value) {
           const candidate = value;
           return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
         }
-        Range4.is = is;
+        Range5.is = is;
       })(Range || (Range = {}));
       (function(Location4) {
         function create(uri, range) {
@@ -12435,7 +12435,7 @@ ${JSON.stringify(message, null, 4)}`);
         }
         uinteger3.is = is;
       })(uinteger2 || (uinteger2 = {}));
-      (function(Position4) {
+      (function(Position5) {
         function create(line, character) {
           if (line === Number.MAX_VALUE) {
             line = uinteger2.MAX_VALUE;
@@ -12445,14 +12445,14 @@ ${JSON.stringify(message, null, 4)}`);
           }
           return { line, character };
         }
-        Position4.create = create;
+        Position5.create = create;
         function is(value) {
           let candidate = value;
           return Is2.objectLiteral(candidate) && Is2.uinteger(candidate.line) && Is2.uinteger(candidate.character);
         }
-        Position4.is = is;
+        Position5.is = is;
       })(Position2 || (Position2 = {}));
-      (function(Range4) {
+      (function(Range5) {
         function create(one, two, three, four) {
           if (Is2.uinteger(one) && Is2.uinteger(two) && Is2.uinteger(three) && Is2.uinteger(four)) {
             return { start: Position2.create(one, two), end: Position2.create(three, four) };
@@ -12462,12 +12462,12 @@ ${JSON.stringify(message, null, 4)}`);
             throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
           }
         }
-        Range4.create = create;
+        Range5.create = create;
         function is(value) {
           let candidate = value;
           return Is2.objectLiteral(candidate) && Position2.is(candidate.start) && Position2.is(candidate.end);
         }
-        Range4.is = is;
+        Range5.is = is;
       })(Range2 || (Range2 = {}));
       (function(Location4) {
         function create(uri, range) {
@@ -131659,6 +131659,7 @@ ${JSON.stringify(message, null, 4)}`);
       const selectionRange = anonymous ? ctx.start ? tokenToRange(ctx.start) : range : this.extractNameRange(ctx) ?? range;
       const typeNames = isFlowUsage(kind) ? this.extractFlowTypeNames(ctx) : transition ? this.extractTransitionTypeNames(ctx) : this.extractTypeNames(ctx);
       const specializationNames = this.extractSpecializationNames(ctx);
+      const redefinedFeatureTargets = this.extractRedefinedFeatureTargets(ctx);
       const typeName = typeNames[0];
       const documentation = this.extractDocumentation(ctx);
       const visibility = this.extractVisibility(ctx);
@@ -131689,6 +131690,7 @@ ${JSON.stringify(message, null, 4)}`);
         typeName,
         typeNames,
         specializationNames,
+        redefinedFeatureTargets: redefinedFeatureTargets.length > 0 ? redefinedFeatureTargets : void 0,
         documentation,
         visibility,
         source: transition?.source,
@@ -131940,15 +131942,28 @@ ${JSON.stringify(message, null, 4)}`);
      * such as `#metadata`.
      */
     findOwnHeaderRule(ctx, ruleIndex) {
+      const matches = [];
+      this.findOwnHeaderRules(ctx, ruleIndex, matches, true);
+      return matches[0];
+    }
+    findOwnHeaderRules(ctx, ruleIndex, matches, firstOnly = false) {
       for (let i = 0; i < ctx.getChildCount(); i++) {
         const child = ctx.getChild(i);
         if (!(child instanceof ParserRuleContext)) continue;
-        if (child.ruleIndex === ruleIndex) return child;
+        if (child.ruleIndex === ruleIndex) {
+          matches.push(child);
+          if (firstOnly) return;
+          continue;
+        }
         if (RULE_INDEX_TO_KIND.has(child.ruleIndex) || BODY_RULE_INDICES.has(child.ruleIndex) || child.ruleIndex === SysMLv2Parser.RULE_valuePart || FLOW_PART_RULE_INDICES.has(child.ruleIndex) || child.ruleIndex === SysMLv2Parser.RULE_ownedCrossMultiplicityMember || this.isPrefixOrExtensionContext(child)) continue;
-        const found = this.findOwnHeaderRule(child, ruleIndex);
-        if (found) return found;
+        this.findOwnHeaderRules(child, ruleIndex, matches, firstOnly);
+        if (firstOnly && matches.length > 0) return;
       }
-      return void 0;
+    }
+    extractRedefinedFeatureTargets(ctx) {
+      const targets = [];
+      this.findOwnHeaderRules(ctx, SysMLv2Parser.RULE_ownedRedefinition, targets);
+      return targets.map((target) => target.getText());
     }
     /**
      * A connection, interface or allocation usage's end reference paths, in
@@ -131976,13 +131991,7 @@ ${JSON.stringify(message, null, 4)}`);
       const segment = reference.getText().split(/::|\./).pop();
       return segment ? this.unquoteName(segment) : void 0;
     }
-    /**
-     * An element's declaration as written, without its body: its tokens up to
-     * its body or closing `;`, each exactly as written (a quoted name keeps its
-     * spaces), with one space wherever the source has whitespace or a comment
-     * between two of them (`connect a.p to b.p`, `connection : Conn`).
-     */
-    declarationText(ctx) {
+    declarationTokens(ctx) {
       const tokens = [];
       const visit = (node) => {
         for (let i = 0; i < node.getChildCount(); i++) {
@@ -131997,6 +132006,16 @@ ${JSON.stringify(message, null, 4)}`);
         return false;
       };
       visit(ctx);
+      return tokens;
+    }
+    /**
+     * An element's declaration as written, without its body: its tokens up to
+     * its body or closing `;`, each exactly as written (a quoted name keeps its
+     * spaces), with one space wherever the source has whitespace or a comment
+     * between two of them (`connect a.p to b.p`, `connection : Conn`).
+     */
+    declarationText(ctx) {
+      const tokens = this.declarationTokens(ctx);
       let text = "";
       tokens.forEach((token, i) => {
         if (i > 0 && token.start > tokens[i - 1].stop + 1) text += " ";
@@ -132137,17 +132156,16 @@ ${JSON.stringify(message, null, 4)}`);
       const names = [];
       this.collectTypeNamesFromTree(ctx, names, 0);
       if (names.length > 0) return names;
-      const fullText = ctx.getText();
-      const braceIdx = fullText.indexOf("{");
-      let text = braceIdx >= 0 ? fullText.substring(0, braceIdx) : fullText;
+      const { text: declarationText, quotedName } = this.maskedDeclaration(ctx);
+      let text = declarationText;
       text = text.replace(RE_KEYWORD_TRUNCATE, "");
       const specMatch = text.match(RE_SPEC);
       if (specMatch) {
         const specStr = text.substring(text.indexOf(specMatch[0]) + specMatch[0].indexOf(specMatch[1]));
         for (const part of specStr.split(",")) {
-          const qm = part.match(RE_QUOTED_NAME);
-          if (qm) {
-            names.push(qm[1]);
+          const quoted = quotedName(part);
+          if (quoted !== void 0) {
+            names.push(quoted);
             continue;
           }
           const m2 = part.trim().match(RE_IDENT_START);
@@ -132168,9 +132186,9 @@ ${JSON.stringify(message, null, 4)}`);
         const fullMatchIdx = text.indexOf(typingMatch[0]);
         const afterColon = text.substring(fullMatchIdx + 1).trim();
         for (const part of afterColon.split(",")) {
-          const qm = part.match(RE_QUOTED_NAME);
-          if (qm) {
-            names.push(qm[1]);
+          const quoted = quotedName(part);
+          if (quoted !== void 0) {
+            names.push(quoted);
             continue;
           }
           const m2 = part.trim().match(RE_IDENT_START);
@@ -132180,6 +132198,28 @@ ${JSON.stringify(message, null, 4)}`);
       }
       return names;
     }
+    /**
+     * The declaration tokens before the body, with each lexer STRING token
+     * replaced by a numbered placeholder (`'0'`, `'1'`, ...), and
+     * `quotedName`, which turns a placeholder in a part of that text back into
+     * the name. SysML 2.0 section 7.2.2 permits punctuation in unrestricted
+     * names (the STRING lexer production), so fallback regexes must never see
+     * their `:`, `:>`, `{` or keywords. Documentation is not a name token.
+     */
+    maskedDeclaration(ctx) {
+      const quoted = [];
+      const masked = this.declarationTokens(ctx).map((token) => {
+        const text = token.text ?? "";
+        return token.type === SysMLv2Lexer.STRING ? `'${quoted.push(text.slice(1, -1)) - 1}'` : text;
+      }).join("");
+      return {
+        text: masked,
+        quotedName: (part) => {
+          const qm = part.match(RE_QUOTED_NAME);
+          return qm ? quoted[Number(qm[1])] : void 0;
+        }
+      };
+    }
     /**
      * Extract only the specialization names (:> / specializes / subsets) from a context.
      * Uses the same tree-walk as extractTypeNames but restricted to
@@ -132190,17 +132230,15 @@ ${JSON.stringify(message, null, 4)}`);
       const names = [];
       this.collectNamesFromTree(ctx, names, 0, TYPE_SPECIALIZATION_RULE_INDICES);
       if (names.length > 0) return names;
-      const fullText = ctx.getText();
-      const braceIdx = fullText.indexOf("{");
-      let text = braceIdx >= 0 ? fullText.substring(0, braceIdx) : fullText;
-      text = text.replace(RE_KEYWORD_TRUNCATE_SPEC, "");
+      const { text: declarationText, quotedName } = this.maskedDeclaration(ctx);
+      const text = declarationText.replace(RE_KEYWORD_TRUNCATE_SPEC, "");
       const specMatch = text.match(RE_SPEC_WITH_SUBSETS);
       if (specMatch) {
         const specStr = text.substring(text.indexOf(specMatch[0]) + specMatch[0].indexOf(specMatch[1]));
         for (const part of specStr.split(",")) {
-          const qm = part.match(RE_QUOTED_NAME);
-          if (qm) {
-            names.push(qm[1]);
+          const quoted = quotedName(part);
+          if (quoted !== void 0) {
+            names.push(quoted);
             continue;
           }
           const m2 = part.trim().match(RE_IDENT_START);
@@ -136405,14 +136443,21 @@ ${JSON.stringify(message, null, 4)}`);
      * namespace.
      */
     isLocallyVisible(symbol, name, indexes) {
-      return this.resolveQualifiedNameFrom(ownerKeyOf(symbol, indexes.byId), name, indexes) !== void 0;
+      return this.resolveNameFrom(symbol, name, indexes) !== void 0;
+    }
+    /**
+     * Resolve a (possibly qualified) name from the namespace containing
+     * `symbol`, respecting namespace membership and visibility.
+     */
+    resolveNameFrom(symbol, name, indexes) {
+      return this.resolveQualifiedNameFrom(ownerKeyOf(symbol, indexes.byId), name, 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
      * members first, then its parent's, ...). Shared by `isLocallyVisible` (an
-     * ordinary reference resolving relative to its own enclosing namespace) and
-     * import-target resolution (an `import` declaration's target is itself a
+     * ordinary reference resolving relative to its own enclosing namespace),
+     * `resolveNameFrom`, and import-target resolution (an `import` declaration's target is itself a
      * qualifiedName, resolved the same relative way -- not as an absolute/global
      * name -- so a bare `import C;` inside a nested package can pick up a `C`
      * its own enclosing package already imported, per §7.5.1/§7.5.3).
@@ -140622,6 +140667,13 @@ ${info.documentation}`);
     "assert",
     "assume"
   ]);
+  var CONNECTOR_KINDS = /* @__PURE__ */ new Set([
+    "connection" /* ConnectionUsage */,
+    "interface" /* InterfaceUsage */,
+    "allocation" /* AllocationUsage */,
+    "flow" /* FlowUsage */,
+    "succession flow" /* SuccessionFlowUsage */
+  ]);
   var SemanticValidator = class _SemanticValidator {
     constructor(documentManager2) {
       this.documentManager = documentManager2;
@@ -140698,7 +140750,7 @@ ${info.documentation}`);
       diagnostics.push(...this.checkAmbiguousNamespaceName(symbols, allSymbols));
       diagnostics.push(...this.checkUnusedDefinitions(allSymbols, uri));
       diagnostics.push(...this.checkRedefinitionMultiplicity(symbols, indexes, text));
-      diagnostics.push(...this.checkPortCompatibility(text, uri, indexes));
+      diagnostics.push(...this.checkPortCompatibility(text, uri, symbols, indexes));
       diagnostics.push(...this.checkConstraintBodyReferences(text, uri, symbols, indexes));
       diagnostics.push(...this.checkCircularSpecialization(symbols, indexes));
       diagnostics.push(...this.checkUnsatisfiedRequirements(symbols, indexes));
@@ -140919,7 +140971,7 @@ ${info.documentation}`);
         opts?.text ? [opts.text] : []
       ));
       if (opts?.text && opts.uri) {
-        diagnostics.push(...instance.checkPortCompatibility(opts.text, opts.uri, indexes));
+        diagnostics.push(...instance.checkPortCompatibility(opts.text, opts.uri, symbolsInUri, indexes));
         diagnostics.push(...instance.checkConstraintBodyReferences(opts.text, opts.uri, symbolsInUri, indexes));
       }
       return instance.dedupeDiagnostics(diagnostics);
@@ -141282,17 +141334,20 @@ ${info.documentation}`);
      * - The connection is within an interface usage
      * - Both ports are untyped (empty port defs with no features)
      */
-    checkPortCompatibility(text, uri, indexes) {
+    checkPortCompatibility(text, uri, symbolsInUri, indexes) {
       if (!text) return [];
       const diagnostics = [];
       const lines = text.split("\n");
       const re = /\bconnect\s+([A-Za-z_][\w.]*)\s+to\s+([A-Za-z_][\w.]*)/g;
       let m2;
       while ((m2 = re.exec(text)) !== null) {
-        const left = m2[1].split(".").pop();
-        const right = m2[2].split(".").pop();
-        const lSym = (indexes.portsByName.get(left) ?? [])[0];
-        const rSym = (indexes.portsByName.get(right) ?? [])[0];
+        const leftPath = m2[1].split(".");
+        const rightPath = m2[2].split(".");
+        const left = leftPath[leftPath.length - 1];
+        const right = rightPath[rightPath.length - 1];
+        const scope = this.connectorScope(symbolsInUri, this.indexToRange(text, m2.index, 0).start, indexes);
+        const lSym = this.resolveConnectorEnd(leftPath, scope, indexes);
+        const rSym = this.resolveConnectorEnd(rightPath, scope, indexes);
         if (!lSym || !rSym) continue;
         const lType = lSym.typeNames[0] ?? lSym.typeName;
         const rType = rSym.typeNames[0] ?? rSym.typeName;
@@ -141342,6 +141397,55 @@ ${info.documentation}`);
       }
       return diagnostics;
     }
+    /**
+     * The innermost element around `position` that owns a connector declared
+     * there: the connector's own symbol, when it has one, is skipped.
+     */
+    connectorScope(symbols, position, indexes) {
+      const before = (a, b) => a.line < b.line || a.line === b.line && a.character <= b.character;
+      const size = (r) => (r.end.line - r.start.line) * 1e6 + (r.end.character - r.start.character);
+      let scope;
+      for (const s of symbols) {
+        if (!before(s.range.start, position) || !before(position, s.range.end)) continue;
+        if (!scope || size(s.range) < size(scope.range)) scope = s;
+      }
+      while (scope && CONNECTOR_KINDS.has(scope.kind)) scope = ownerOf(scope, indexes);
+      return scope;
+    }
+    /**
+     * The port that a connector end (`a.p`, `a.p.q`) names, resolved from
+     * `scope` outward: its first segment is a feature of `scope` or of one of
+     * its owners, each next one a feature of the one before. Two parts can each
+     * have a port of the same name, so an end is never matched by its last
+     * segment alone, except when the path does not resolve and the workspace
+     * has only one port of that name.
+     */
+    resolveConnectorEnd(path, scope, indexes) {
+      let feature;
+      for (let namespace = scope; namespace && !feature; namespace = ownerOf(namespace, indexes)) {
+        feature = this.findFeature(namespace, path[0], indexes);
+      }
+      for (const name of path.slice(1)) {
+        feature = feature && this.findFeature(feature, name, indexes);
+      }
+      if (feature) return feature.kind === "port" /* PortUsage */ ? feature : void 0;
+      const sameName = indexes.portsByName.get(path[path.length - 1]) ?? [];
+      return sameName.length === 1 ? sameName[0] : void 0;
+    }
+    /** The feature `name` of `owner`: its own member, else a member of one of its types or their supertypes. */
+    findFeature(owner, name, indexes) {
+      const own = (indexes.byParent.get(namespaceKeyOf(owner)) ?? []).find((s) => s.name === name);
+      if (own) return own;
+      for (const typeName of owner.typeNames) {
+        const type = this.namespaceResolver.resolveNameFrom(owner, typeName, indexes);
+        if (!type || !isDefinition(type.kind)) continue;
+        for (const definition of this.getSpecializationHierarchy(type, indexes).flat()) {
+          const member = (indexes.byParent.get(namespaceKeyOf(definition)) ?? []).find((s) => s.name === name);
+          if (member) return member;
+        }
+      }
+      return void 0;
+    }
     /**
      * Resolve the full type hierarchy for a type name by following
      * specialization chains transitively (max depth 10).
@@ -141389,7 +141493,7 @@ ${info.documentation}`);
         }
         const parent = this.findConstraintScopeSymbol(symbolsInUri, indexes, b.startLine);
         if (!parent) continue;
-        const parentMembers = indexes.byParent.get(namespaceKeyOf(parent)) ?? [];
+        const parentMembers = this.getConstraintScopeMembers(parent, indexes);
         if (parentMembers.length === 0) continue;
         const ignoredRanges = this.getIgnoredBodyRanges(b.body);
         const idRe = /\b([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*)\b/g;
@@ -141448,18 +141552,135 @@ ${info.documentation}`);
       const root = parentMembers.find((s) => s.name === path[0]);
       if (!root) return false;
       if (path.length === 1) return true;
-      let typeName = root.typeNames[0] ?? root.typeName;
+      let current = root;
       for (let i = 1; i < path.length; i++) {
+        const typeName = current.typeNames[0] ?? current.typeName;
         if (!typeName) return false;
-        const typeDefs = indexes.definitionsByName.get(typeName) ?? [];
-        const typeDef = typeDefs[0];
-        if (!typeDef) return false;
-        const member = (indexes.byParent.get(namespaceKeyOf(typeDef)) ?? []).find((s) => s.name === path[i]);
+        const typeDef = this.namespaceResolver.resolveNameFrom(current, typeName, indexes);
+        if (!typeDef || !isDefinition(typeDef.kind)) return false;
+        const member = this.getConstraintScopeMembers(typeDef, indexes, true).find((s) => s.name === path[i]);
         if (!member) return false;
-        typeName = member.typeNames[0] ?? member.typeName;
+        current = member;
       }
       return true;
     }
+    getConstraintScopeMembers(scope, indexes, publicOnly = false) {
+      const hierarchy = [[scope]];
+      const visited = /* @__PURE__ */ new Set([scope]);
+      let frontier = [scope];
+      while (frontier.length > 0) {
+        const next = [];
+        for (const current of frontier) {
+          for (const typeName of current.typeNames) {
+            const supertype = this.namespaceResolver.resolveNameFrom(current, typeName, indexes);
+            if (!supertype || !isDefinition(supertype.kind) || visited.has(supertype)) continue;
+            visited.add(supertype);
+            next.push(supertype);
+          }
+        }
+        if (next.length > 0) hierarchy.push(next);
+        frontier = next;
+      }
+      const membersByLevel = hierarchy.map((level) => level.flatMap((namespace) => indexes.byParent.get(namespaceKeyOf(namespace)) ?? []));
+      const hiddenMembers = /* @__PURE__ */ new Set();
+      for (let level = membersByLevel.length - 1; level >= 0; level--) {
+        for (const redefining of membersByLevel[level]) {
+          for (const target of redefining.redefinedFeatureTargets ?? []) {
+            const owner = ownerOf(redefining, indexes);
+            if (!owner) continue;
+            for (const candidate of this.resolveInheritedRedefinitionTarget(owner, target, hiddenMembers, indexes)) {
+              hiddenMembers.add(candidate.symbolId);
+            }
+          }
+          if (redefining.kind === "subject" /* SubjectUsage */) {
+            const owner = ownerOf(redefining, indexes);
+            if (!owner) continue;
+            for (const ancestor of this.getSpecializationHierarchy(owner, indexes).slice(1).flat()) {
+              for (const candidate of indexes.byParent.get(namespaceKeyOf(ancestor)) ?? []) {
+                if (candidate.kind === "subject" /* SubjectUsage */) hiddenMembers.add(candidate.symbolId);
+              }
+            }
+          }
+        }
+      }
+      const membersByName = /* @__PURE__ */ new Map();
+      for (let level = 0; level < membersByLevel.length; level++) {
+        for (const member of membersByLevel[level]) {
+          if (level > 0 && member.visibility === "private") continue;
+          if (publicOnly && member.visibility !== void 0 && member.visibility !== "public") continue;
+          if (hiddenMembers.has(member.symbolId) || membersByName.has(member.name)) continue;
+          membersByName.set(member.name, member);
+        }
+      }
+      return [...membersByName.values()];
+    }
+    resolveInheritedRedefinitionTarget(owner, target, alreadyRedefined, indexes) {
+      if (target.includes(".")) return [];
+      const segments = target.split("::");
+      const targetName = segments.pop()?.replace(/^'|'$/g, "");
+      if (!targetName) return [];
+      const qualifier = segments.join("::").replace(/^'|'$/g, "");
+      const matches = /* @__PURE__ */ new Map();
+      for (const supertype of this.resolveDirectSupertypes(owner, indexes)) {
+        const branch = this.getSpecializationHierarchy(supertype, indexes);
+        const anchors = qualifier ? branch.flat().filter((type) => this.matchesSpecializationQualifier(type, qualifier)) : [supertype];
+        for (const anchor of anchors) {
+          let frontier = [anchor];
+          const visited = new Set(frontier);
+          const candidates = [];
+          while (frontier.length > 0 && candidates.length === 0) {
+            for (const type of frontier) {
+              for (const member of indexes.byParent.get(namespaceKeyOf(type)) ?? []) {
+                if (member.name === targetName && member.visibility !== "private" && !alreadyRedefined.has(member.symbolId)) {
+                  candidates.push(member);
+                }
+              }
+            }
+            if (candidates.length > 0) break;
+            const next = /* @__PURE__ */ new Map();
+            for (const type of frontier) {
+              for (const parent of this.resolveDirectSupertypes(type, indexes)) {
+                if (visited.has(parent)) continue;
+                visited.add(parent);
+                next.set(parent.symbolId, parent);
+              }
+            }
+            frontier = [...next.values()];
+          }
+          for (const candidate of candidates) matches.set(candidate.symbolId, candidate);
+        }
+      }
+      return matches.size === 1 ? [...matches.values()] : [];
+    }
+    resolveDirectSupertypes(scope, indexes) {
+      const supertypes = /* @__PURE__ */ new Map();
+      for (const typeName of scope.typeNames) {
+        const supertype = this.namespaceResolver.resolveNameFrom(scope, typeName, indexes);
+        if (supertype && isDefinition(supertype.kind)) supertypes.set(supertype.symbolId, supertype);
+      }
+      return [...supertypes.values()];
+    }
+    getSpecializationHierarchy(scope, indexes) {
+      const levels = [[scope]];
+      const visited = /* @__PURE__ */ new Set([scope]);
+      let frontier = [scope];
+      while (frontier.length > 0) {
+        const next = [];
+        for (const type of frontier) {
+          for (const parent of this.resolveDirectSupertypes(type, indexes)) {
+            if (visited.has(parent)) continue;
+            visited.add(parent);
+            next.push(parent);
+          }
+        }
+        if (next.length > 0) levels.push(next);
+        frontier = next;
+      }
+      return levels;
+    }
+    matchesSpecializationQualifier(type, qualifier) {
+      return type.name === qualifier || type.qualifiedName === qualifier || type.qualifiedName?.endsWith(`::${qualifier}`) === true;
+    }
     findContainingSymbolByLine(symbols, line) {
       return symbols.filter((s) => s.range.start.line <= line && s.range.end.line >= line).sort((a, b) => {
         const ar = (a.range.end.line - a.range.start.line) * 1e3 + (a.range.end.character - a.range.start.character);
@@ -141470,7 +141691,7 @@ ${info.documentation}`);
     findConstraintScopeSymbol(symbolsInUri, indexes, line) {
       let scope = this.findContainingSymbolByLine(symbolsInUri, line);
       while (scope) {
-        const members = indexes.byParent.get(namespaceKeyOf(scope)) ?? [];
+        const members = this.getConstraintScopeMembers(scope, indexes);
         if (members.length > 0) return scope;
         if (!scope.parentId) return scope;
         scope = ownerOf(scope, indexes);
@@ -142065,7 +142286,8 @@ ${info.documentation}`);
       if (loggedFolderPrefixes.get(folderUri) === prefix) continue;
       loggedFolderPrefixes.set(folderUri, prefix);
       const source = ownProjectIds.has(folderUri) ? "its projectId" : prefix === getUrlPrefix() ? prefix === DEFAULT_URL_PREFIX ? "the default prefix, no projectId" : "initializationOptions.projectId" : "an enclosing folder's projectId";
-      connection.console.info(`Folder ${folderUri}: top-level elements' URLs start with ${prefix} (${source})`);
+      const folderPath = toFsPath(folderUri) ?? folderUri;
+      connection.console.debug(`Folder ${folderPath}: element ID namespace ${prefix} (${source}; ID namespace only, no network access)`);
     }
     for (const folderUri of loggedFolderPrefixes.keys()) {
       if (!workspaceFolderUris.includes(folderUri)) loggedFolderPrefixes.delete(folderUri);