sysml-validate 0.20.3 → 0.21.1

package/out/main.js

@@ -59979,9 +59979,16 @@ function nameOf(node) {
   const name = node?.name;
   if (typeof name === "string" && name.length > 0)
     return name;
-  if (node?.$type === "FeatureRedefinitionShorthand") {
-    const leading = node.preRelationships?.[0]?.targets?.[0];
-    return leading ? lastSegment2(leading) : void 0;
+  const relational = node;
+  for (const relationship of [
+    ...relational?.preRelationships ?? [],
+    ...relational?.relationships ?? []
+  ]) {
+    if (relationship.kind !== ":>>" && relationship.kind !== "redefines")
+      continue;
+    const target = relationship.targets?.[0];
+    if (target)
+      return lastSegment2(target);
   }
   if (node?.$type === "FeatureShorthand") {
     const text = node.$cstNode?.text;
@@ -59998,9 +60005,16 @@ function nameOf(node) {
   return void 0;
 }
 function unwrap(node) {
-  if (node.$type !== "PrefixMetadataMember")
-    return node;
-  return node.element ?? node;
+  let current2 = node;
+  const seen = /* @__PURE__ */ new Set();
+  while ((current2.$type === "PrefixMetadataMember" || current2.$type === "MemberPrefixDecl") && !seen.has(current2)) {
+    seen.add(current2);
+    const element = current2.element;
+    if (!element)
+      break;
+    current2 = element;
+  }
+  return current2;
 }
 function directNamedChildren(node) {
   const result = [];
@@ -60031,12 +60045,32 @@ function isSelfReference(candidate, node) {
 function lastSegment2(path10) {
   return path10.split(/::|\./u).pop() ?? path10;
 }
+function simpleRelationName(path10) {
+  let quoted = false;
+  for (let index = 0; index < path10.length; index += 1) {
+    const char = path10[index];
+    if (quoted) {
+      if (char === "\\")
+        index += 1;
+      else if (char === "'")
+        quoted = false;
+      continue;
+    }
+    if (char === "'")
+      quoted = true;
+    else if (char === "." || char === ":" && path10[index + 1] === ":")
+      return void 0;
+  }
+  const withoutMultiplicity = path10.replace(/\s*\[[^\]]*\]\s*$/u, "").trim();
+  return withoutMultiplicity ? canonicalEscapedName(withoutMultiplicity) : void 0;
+}
 var FeaturePathResolver = class {
   indexManager;
   descriptions;
   documents;
   locator;
   snapshots = /* @__PURE__ */ new WeakMap();
+  resolvingSpecializations = /* @__PURE__ */ new Set();
   constructor(services) {
     this.indexManager = services?.shared.workspace.IndexManager;
     this.descriptions = services?.workspace.AstNodeDescriptionProvider;
@@ -60139,6 +60173,14 @@ var FeaturePathResolver = class {
     }
     return result;
   }
+  /** Semantic owners reached through typing and specialization. This is used
+   * when an anonymous redefinition has no keyword from which to recover its
+   * feature kind. */
+  // REQ-364: recover the semantic kind of an anonymous local redefinition.
+  inheritedOwners(node) {
+    const root3 = ast_utils_exports.getDocument(node).parseResult.value;
+    return this.typedAndSpecializedOwners(node, this.snapshot(root3));
+  }
   segmentsOf(node) {
     const cst = node.$cstNode;
     if (!cst)
@@ -60284,20 +60326,45 @@ var FeaturePathResolver = class {
     return typed;
   }
   specializationTargets(node, snapshot) {
+    if (this.resolvingSpecializations.has(node))
+      return [];
+    this.resolvingSpecializations.add(node);
     const relNode = node;
     const result = [];
-    for (const relation of [...relNode.preRelationships ?? [], ...relNode.relationships ?? []]) {
-      if (!relation.kind || !SPECIALIZATION_KINDS2.has(relation.kind))
-        continue;
-      for (const target of relation.targets ?? []) {
-        const description = this.pickDescription(snapshot.byName.get(target)) ?? this.pickDescription(snapshot.byName.get(lastSegment2(target)));
-        const resolved = this.nodeOf(description);
-        if (resolved)
-          result.push(resolved);
+    try {
+      for (const relation of [...relNode.preRelationships ?? [], ...relNode.relationships ?? []]) {
+        if (!relation.kind || !SPECIALIZATION_KINDS2.has(relation.kind))
+          continue;
+        for (const target of relation.targets ?? []) {
+          const simple = simpleRelationName(target);
+          const scoped = simple ? this.scopedSpecializationTarget(node, simple, snapshot) : void 0;
+          const description = scoped ? void 0 : this.pickDescription(snapshot.byName.get(target), node) ?? this.pickDescription(snapshot.byName.get(lastSegment2(target)), node);
+          const resolved = scoped ?? this.nodeOf(description);
+          if (resolved)
+            result.push(resolved);
+        }
       }
+    } finally {
+      this.resolvingSpecializations.delete(node);
     }
     return result;
   }
+  /** A simple feature specialization is resolved in the visible inventory of
+   * its lexical owner. Only an absent scoped match may fall back to the global
+   * index, which prevents an unrelated same-named feature from winning. */
+  scopedSpecializationTarget(node, name, snapshot) {
+    for (let scope = node.$container; scope; scope = scope.$container) {
+      const local = directNamedChildren(scope).find((candidate) => candidate !== node && nameOf(candidate) === name);
+      if (local)
+        return local;
+      for (const owner of this.typedAndSpecializedOwners(scope, snapshot)) {
+        const inherited = directNamedChildren(owner).find((candidate) => candidate !== node && nameOf(candidate) === name);
+        if (inherited)
+          return inherited;
+      }
+    }
+    return void 0;
+  }
   memberInventoryKnown(node, snapshot) {
     const record = node;
     if (record.isDef === true || node.$type === "ClassDecl" || node.$type === "StructDecl" || node.$type === "EnumDecl" || node.$type === "DatatypeDecl" || node.$type === "FunctionDecl" || node.$type === "PredicateDecl") {
@@ -68396,6 +68463,20 @@ var SysmlLinker = class extends DefaultLinker {
   resolveIndexedNode(nodeDescription) {
     return this.loadAstNode(nodeDescription);
   }
+  // REQ-210 — Annotation graphics
+  /**
+   * Return the parsed root for a live workspace or lazily loaded library file.
+   * Diagram projection uses this to collect annotations declared beside an
+   * inherited member without adding standard-library files to the workspace.
+   */
+  resolveDocumentRoot(uri) {
+    const live = this.langiumDocuments().getDocument(uri)?.parseResult?.value;
+    if (live)
+      return live;
+    if (!isStandardLibraryUri(uri))
+      return void 0;
+    return this.parsedLibraryDocument(uri)?.parseResult?.value;
+  }
   /** Parse (once) the standard-library file a precomputed description points at.
    *  Prefers an already-live workspace document when one exists (runtime-loaded
    *  library, or the user opened the file) so there is never a second copy. */
@@ -72238,7 +72319,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.20.3" : "dev";
+var VERSION2 = true ? "0.21.1" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {