sysml-diagram 0.31.0 → 0.31.2

package/out/main.js

@@ -162534,6 +162534,26 @@ function isPublic(node) {
   return true;
 }
 var SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var inheritanceByNode = /* @__PURE__ */ new WeakMap();
+function inheritanceSyntax(node) {
+  const cached = inheritanceByNode.get(node);
+  if (cached)
+    return cached;
+  const shape = node;
+  const relationships = [...shape.preRelationships ?? [], ...shape.relationships ?? []].filter((relation) => relation.kind && SPECIALIZATION_KINDS.has(relation.kind));
+  const implicitVariant = implicitVariantSpecialization(node)?.target;
+  const externalVariant = !!externalVariantPath(node);
+  const enumUsage = node.$type === "EnumDecl" && shape.isDef !== true;
+  const result = {
+    relationships,
+    implicitVariant,
+    externalVariant,
+    enumUsage,
+    hasSources: !!shape.typing || relationships.length > 0 || !!implicitVariant || externalVariant || enumUsage
+  };
+  inheritanceByNode.set(node, result);
+  return result;
+}
 function nameOf(node) {
   if (node) {
     const external = externalVariantName(node);
@@ -162690,6 +162710,11 @@ var FeaturePathResolver = class {
   linker;
   scopeProvider;
   snapshots = /* @__PURE__ */ new WeakMap();
+  indexedSnapshot;
+  // REQ-361 - Inheritance walks memoized against the snapshot they were read
+  // from; a new snapshot answers fresh. Keyed weakly, so a re-parsed document
+  // drops its entries with its nodes.
+  owners = /* @__PURE__ */ new WeakMap();
   propertySegments = /* @__PURE__ */ new WeakMap();
   resolvingSpecializations = /* @__PURE__ */ new Set();
   enumerationPathDepth = 0;
@@ -162700,9 +162725,12 @@ var FeaturePathResolver = class {
     this.locator = services?.workspace.AstNodeLocator;
     this.linker = services?.references.Linker;
     this.scopeProvider = services?.references.ScopeProvider;
-    services?.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
-      this.snapshots = /* @__PURE__ */ new WeakMap();
-    });
+    services?.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => this.dropSnapshots());
+    services?.shared.workspace.DocumentBuilder.onUpdate(() => this.dropSnapshots());
+  }
+  dropSnapshots() {
+    this.snapshots = /* @__PURE__ */ new WeakMap();
+    this.indexedSnapshot = void 0;
   }
   // REQ-220/317 — resolve every independently clickable/diagnosable segment.
   resolve(node) {
@@ -163167,7 +163195,22 @@ var FeaturePathResolver = class {
     }
     return {};
   }
+  // REQ-361 - The inheritance walk is the hot path of every written-path
+  // resolution, and a document resolves the same owners over and over: once per
+  // path that mentions them, and again for every reference tally a CodeLens
+  // pass asks for. The answer only changes with the syntax (fixed for a parse)
+  // and the index generation, so it is memoized against the snapshot that
+  // produced it. A walk that ran INSIDE a specialization cycle sees the cycle
+  // guard's empty answer, so only a top-level walk is cached.
   typedAndSpecializedOwners(node, snapshot) {
+    const syntax = inheritanceSyntax(node);
+    if (!syntax.hasSources)
+      return [];
+    const cacheable = this.resolvingSpecializations.size === 0;
+    const depthZero = this.enumerationPathDepth === 0;
+    const cached = this.owners.get(node);
+    if (cached && cached.snapshot === snapshot && cached.depthZero === depthZero)
+      return cached.owners;
     const result = [];
     const seen = /* @__PURE__ */ new Set();
     const visit = (candidate) => {
@@ -163175,15 +163218,20 @@ var FeaturePathResolver = class {
         return;
       seen.add(candidate);
       result.push(candidate);
-      visit(this.externalVariantTarget(candidate));
-      visit(implicitVariantSpecialization(candidate)?.target);
+      const inheritedSyntax = inheritanceSyntax(candidate);
+      if (!inheritedSyntax.hasSources)
+        return;
+      if (inheritedSyntax.externalVariant)
+        visit(this.externalVariantTarget(candidate));
+      visit(inheritedSyntax.implicitVariant);
       visit(this.inferredEnumerationTarget(candidate));
       visit(this.isEnumUsage(candidate) ? this.enumerationTypingTarget(candidate) : this.typingTarget(candidate, snapshot));
       for (const specialized of this.specializationTargets(candidate, snapshot))
         visit(specialized);
     };
-    visit(this.externalVariantTarget(node));
-    visit(implicitVariantSpecialization(node)?.target);
+    if (syntax.externalVariant)
+      visit(this.externalVariantTarget(node));
+    visit(syntax.implicitVariant);
     visit(this.inferredEnumerationTarget(node));
     const enumNode = node;
     if (this.enumerationPathDepth === 0 && enumNode.$type === "EnumDecl" && enumNode.isDef !== true && enumNode.value?.$type === "PathExpr" && isEnumerationUsage(enumNode)) {
@@ -163193,6 +163241,8 @@ var FeaturePathResolver = class {
     visit(this.isEnumUsage(node) ? this.enumerationTypingTarget(node) : this.typingTarget(node, snapshot));
     for (const specialized of this.specializationTargets(node, snapshot))
       visit(specialized);
+    if (cacheable)
+      this.owners.set(node, { snapshot, depthZero, owners: result });
     return result;
   }
   inferredEnumerationTarget(node) {
@@ -163253,15 +163303,13 @@ var FeaturePathResolver = class {
     return typed;
   }
   specializationTargets(node, snapshot) {
-    if (this.resolvingSpecializations.has(node))
+    const { relationships } = inheritanceSyntax(node);
+    if (relationships.length === 0 || this.resolvingSpecializations.has(node))
       return [];
     this.resolvingSpecializations.add(node);
-    const relNode = node;
     const result = [];
     try {
-      for (const relation of [...relNode.preRelationships ?? [], ...relNode.relationships ?? []]) {
-        if (!relation.kind || !SPECIALIZATION_KINDS.has(relation.kind))
-          continue;
+      for (const relation of relationships) {
         for (const [index2, target] of (relation.targets ?? []).entries()) {
           const simple = simpleRelationName(target);
           const scoped = simple ? this.scopedSpecializationTarget(node, simple, snapshot) : void 0;
@@ -163353,8 +163401,9 @@ var FeaturePathResolver = class {
     segment.target = target.node;
     segment.description = target.description;
   }
+  // REQ-361/410 - One indexed workspace snapshot, or one per parse-only root.
   snapshot(root4) {
-    const cached = this.snapshots.get(root4);
+    const cached = this.indexManager ? this.indexedSnapshot : this.snapshots.get(root4);
     if (cached)
       return cached;
     const byName = /* @__PURE__ */ new Map();
@@ -163386,7 +163435,10 @@ var FeaturePathResolver = class {
       }
     }
     const snapshot = { byName };
-    this.snapshots.set(root4, snapshot);
+    if (this.indexManager)
+      this.indexedSnapshot = snapshot;
+    else
+      this.snapshots.set(root4, snapshot);
     return snapshot;
   }
 };
@@ -167203,7 +167255,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         multiplicity: this.multText(n2),
         type: typeText(n2) ?? (usageDefinitions.get(n2) ? nameOf2(usageDefinitions.get(n2)) : void 0),
         ...attributeUsages.has(n2) ? { value: attributeValue(n2) } : {},
-        compartments: this.compartmentsFor(n2, uri, index2, shape === "box"),
+        compartments: extra?.compartments ?? this.compartmentsFor(n2, uri, index2, shape === "box"),
         ...packageOf2(n2),
         source: sourceOf2(n2, uri),
         ...extra
@@ -185796,10 +185848,26 @@ var SysmlCodeLensProvider = class {
   constructor(services) {
     this.services = services;
   }
-  // TSK_023 — A "N references" lens above a definition (find-references on click).
-  referencesLens(node, uri, range) {
+  // TSK_023 — Every reference tally this pass needs, from one workspace sweep.
+  // A sweep resolves every written path in every document, so one per lens made
+  // a file with a dozen requirement definitions take seconds and the lenses
+  // never reached the editor.
+  referenceCounts(root4) {
+    const targets = [];
+    walkAst(root4, (node) => {
+      if (isRequirementDecl(node) && node.isDef && node.name)
+        targets.push(node);
+      if (isVerificationCaseDecl(node) && node.isDef && node.name)
+        targets.push(node);
+    });
     const refProvider = this.services.lsp.ReferencesProvider;
-    const count = typeof refProvider?.referenceCount === "function" ? refProvider.referenceCount(node) : 0;
+    if (typeof refProvider?.referenceCounts !== "function")
+      return /* @__PURE__ */ new Map();
+    return refProvider.referenceCounts(targets);
+  }
+  // TSK_023 — A "N references" lens above a definition (find-references on click).
+  referencesLens(node, uri, range, counts) {
+    const count = counts.get(node) ?? 0;
     return {
       range,
       command: {
@@ -185818,6 +185886,7 @@ var SysmlCodeLensProvider = class {
     const uri = document2.uri.toString();
     const requirements = indexByName(root4, "RequirementDecl");
     const parts = indexByName(root4, "PartDecl");
+    const counts = this.referenceCounts(root4);
     walkAst(root4, (node) => {
       const cst = node.$cstNode;
       if (!cst)
@@ -185851,7 +185920,7 @@ var SysmlCodeLensProvider = class {
         });
       }
       if (isRequirementDecl(node) && node.isDef && node.name) {
-        lenses.push(this.referencesLens(node, uri, range));
+        lenses.push(this.referencesLens(node, uri, range, counts));
       }
       if (isVerificationCaseDecl(node) && node.isDef && node.name) {
         const result = evaluateVerificationCase(node, (name) => requirements.get(name), (name) => parts.get(name));
@@ -185871,7 +185940,7 @@ var SysmlCodeLensProvider = class {
             arguments: [uri, node.name]
           }
         });
-        lenses.push(this.referencesLens(node, uri, range));
+        lenses.push(this.referencesLens(node, uri, range, counts));
       }
     });
     return lenses;
@@ -186087,6 +186156,14 @@ var SysmlReferencesProvider = class extends DefaultReferencesProvider {
   referenceCount(target) {
     return this.references.findReferences(target, { includeDeclaration: false }).count();
   }
+  // TSK_023 - One sweep answers every tally a CodeLens pass needs. Counting them
+  // one at a time repeats the whole written-path scan per lens.
+  referenceCounts(targets) {
+    const references = this.references;
+    if (typeof references?.referenceCounts === "function")
+      return references.referenceCounts(targets);
+    return new Map(targets.map((target) => [target, this.referenceCount(target)]));
+  }
 };
 
 // ../language-server/out/src/services/written-path-references.js
@@ -186102,6 +186179,53 @@ var WrittenPathReferences = class extends DefaultReferences {
     const segment = this.paths.segmentAt(source);
     return segment ? segment.target : super.findDeclaration(source);
   }
+  /**
+   * TSK_023 - How many references each target has, in ONE workspace sweep.
+   *
+   * `findReferences` resolves every written path in every document, so asking
+   * it per target multiplies that sweep by the number of targets. A CodeLens
+   * pass over a file with a dozen requirement definitions paid it a dozen
+   * times and took seconds, which reads in the editor as lenses that never
+   * appear. The tally below answers all of them from a single sweep.
+   */
+  referenceCounts(targets) {
+    const counts = new Map(targets.map((target) => [target, 0]));
+    if (targets.length === 0)
+      return counts;
+    const seen = new Map(targets.map((target) => [target, /* @__PURE__ */ new Set()]));
+    const byIdentity = /* @__PURE__ */ new Map();
+    for (const target of targets) {
+      const targetUri = ast_utils_exports.getDocument(target).uri.toString();
+      byIdentity.set(`${targetUri}|${this.nodeLocator.getAstNodePath(target)}`, target);
+      const found = seen.get(target);
+      for (const reference of super.findReferences(target, { includeDeclaration: false })) {
+        const key2 = `${reference.sourceUri}|${reference.segment.offset}`;
+        if (found.has(key2))
+          continue;
+        found.add(key2);
+        counts.set(target, (counts.get(target) ?? 0) + 1);
+      }
+    }
+    for (const document2 of this.documents.all) {
+      for (const node of ast_utils_exports.streamAllContents(document2.parseResult.value)) {
+        for (const path10 of this.paths.writtenPaths(node)) {
+          for (const segment of path10.segments) {
+            const description = segment.description;
+            const target = segment.target && counts.has(segment.target) ? segment.target : description ? byIdentity.get(`${description.documentUri.toString()}|${description.path}`) : void 0;
+            if (!target)
+              continue;
+            const found = seen.get(target);
+            const key2 = `${document2.uri}|${segment.cst.offset}`;
+            if (found.has(key2))
+              continue;
+            found.add(key2);
+            counts.set(target, (counts.get(target) ?? 0) + 1);
+          }
+        }
+      }
+    }
+    return counts;
+  }
   findReferences(target, options) {
     const result = super.findReferences(target, options).toArray();
     const targetUri = ast_utils_exports.getDocument(target).uri;
@@ -209598,7 +209722,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.31.0" : "dev";
+var VERSION2 = true ? "0.31.2" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;