sysml-diagram 0.31.1 → 0.31.2

package/out/main.js

@@ -162710,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;
@@ -162720,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) {
@@ -163187,10 +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) => {
@@ -163221,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) {
@@ -163379,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();
@@ -163412,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;
   }
 };
@@ -185822,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: {
@@ -185844,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)
@@ -185877,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));
@@ -185897,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;
@@ -186113,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
@@ -186128,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;
@@ -209624,7 +209722,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.31.1" : "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;