sysml-validate 0.24.0 → 0.26.0

package/out/main.js

@@ -57970,7 +57970,9 @@ var sysmlInlayHintSettings = {
   modifiers: false,
   specialization: false,
   redefinition: false,
-  effectiveNames: false
+  effectiveNames: false,
+  importedNames: false,
+  parameterNames: false
 };
 function asDiagnosticLevel(value, fallback = "off") {
   return value === "off" || value === "warning" || value === "error" ? value : fallback;
@@ -69973,6 +69975,329 @@ var SysmlSemanticTokenProvider = class extends AbstractSemanticTokenProvider {
 
 // ../language-server/out/src/services/inlay-hint-provider.js
 var import_vscode_languageserver20 = __toESM(require_main4(), 1);
+
+// ../language-server/out/src/services/name-lookup.js
+function unquoteName3(name) {
+  return name.replace(/^'(.*)'$/u, "$1");
+}
+function pathSegments(path10) {
+  const segments = [];
+  let current2 = "";
+  let quoted = false;
+  for (let index = 0; index < path10.length; index++) {
+    const char = path10[index];
+    if (char === "'") {
+      quoted = !quoted;
+      current2 += char;
+      continue;
+    }
+    if (!quoted && char === ":" && path10[index + 1] === ":") {
+      segments.push(current2);
+      current2 = "";
+      index++;
+      continue;
+    }
+    if (!quoted && char === ".") {
+      segments.push(current2);
+      current2 = "";
+      continue;
+    }
+    current2 += char;
+  }
+  segments.push(current2);
+  return segments;
+}
+function simpleNameOf2(name) {
+  return pathSegments(name).at(-1) ?? name;
+}
+var ELEMENT_SEPARATOR = "\0";
+function elementKey2(description) {
+  return `${description.documentUri.toString()}${ELEMENT_SEPARATOR}${description.path}`;
+}
+function isDeclaredSpelling(description) {
+  const kind = description.derivedKind;
+  if (kind === "reexport" || kind === "inherited")
+    return false;
+  return pathSegments(description.name).length === 1;
+}
+var SysmlNameLookup = class {
+  shared;
+  byName;
+  /** Element key → the declared spellings the index holds for that element. */
+  spellings;
+  constructor(shared) {
+    this.shared = shared;
+    this.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
+      this.byName = void 0;
+      this.spellings = void 0;
+    });
+  }
+  /** Every description indexed under `name`, in either spelling of an escaped name. */
+  descriptions(name) {
+    return this.index().get(name) ?? [];
+  }
+  /**
+   * The ONE element `name` names, or `undefined` when the answer is not
+   * certain: no element, or more than one. `accept` narrows the candidates
+   * before ambiguity is judged, so "the only CALLABLE called `f`" is a
+   * decidable question even where a part shares the name.
+   */
+  unique(name, accept) {
+    const candidates = this.descriptions(name).filter((candidate) => !accept || accept(candidate));
+    let found;
+    let key;
+    for (const candidate of candidates) {
+      const candidateKey = elementKey2(candidate);
+      if (found === void 0) {
+        found = candidate;
+        key = candidateKey;
+        continue;
+      }
+      if (candidateKey !== key)
+        return void 0;
+    }
+    return found;
+  }
+  /**
+   * Resolve a written path: the spelling the index holds verbatim first, then
+   * its final segment. Both readings must name exactly one element.
+   */
+  uniqueForPath(path10, accept) {
+    return this.unique(path10, accept) ?? this.unique(simpleNameOf2(path10), accept);
+  }
+  /**
+   * The declared spellings of the element `description` names — its regular
+   * name and its `<short>` name — minus `written`.
+   */
+  otherNames(description, written) {
+    const all = this.spellingIndex().get(elementKey2(description)) ?? [];
+    const seen = unquoteName3(written);
+    return all.filter((name) => unquoteName3(name) !== seen);
+  }
+  index() {
+    if (!this.byName)
+      this.build();
+    return this.byName;
+  }
+  spellingIndex() {
+    if (!this.spellings)
+      this.build();
+    return this.spellings;
+  }
+  /** One pass over the index feeds both maps; neither is worth a second. */
+  build() {
+    const byName = /* @__PURE__ */ new Map();
+    const spellings = /* @__PURE__ */ new Map();
+    const add = (key, description) => {
+      const bucket = byName.get(key);
+      if (bucket)
+        bucket.push(description);
+      else
+        byName.set(key, [description]);
+    };
+    for (const description of this.shared.workspace.IndexManager.allElements()) {
+      add(description.name, description);
+      const unquoted = unquoteName3(description.name);
+      if (unquoted !== description.name)
+        add(unquoted, description);
+      if (!isDeclaredSpelling(description))
+        continue;
+      const key = elementKey2(description);
+      const names = spellings.get(key);
+      if (names) {
+        if (!names.includes(description.name))
+          names.push(description.name);
+      } else {
+        spellings.set(key, [description.name]);
+      }
+    }
+    this.byName = byName;
+    this.spellings = spellings;
+  }
+};
+var lookups = /* @__PURE__ */ new WeakMap();
+function nameLookupFor(shared) {
+  if (!shared)
+    return void 0;
+  const existing = lookups.get(shared);
+  if (existing)
+    return existing;
+  const created = new SysmlNameLookup(shared);
+  lookups.set(shared, created);
+  return created;
+}
+
+// ../language-server/out/src/services/callable-resolver.js
+var CALLABLE_TYPES = /* @__PURE__ */ new Set([
+  "CalcDecl",
+  "ActionDecl",
+  "ConstraintDecl",
+  "FunctionDecl",
+  "PredicateDecl",
+  "BehaviorDecl",
+  "InteractionDecl"
+]);
+var CallableResolver = class {
+  services;
+  lookup;
+  linker;
+  constructor(services) {
+    this.services = services;
+    this.lookup = nameLookupFor(services?.shared);
+    this.linker = services?.references.Linker;
+  }
+  /**
+   * Every indexed callable that answers to `name`, so a caller can decide what
+   * ambiguity costs it. Signature help is transient and follows the cursor, so
+   * it takes the first; an inlay hint is a permanent annotation, so it takes a
+   * candidate only when it is the ONLY element with that name.
+   */
+  candidates(name) {
+    const simple = simpleNameOf2(name);
+    return (this.lookup?.descriptions(simple) ?? []).filter((description) => CALLABLE_TYPES.has(description.type));
+  }
+  /**
+   * The one callable `name` unambiguously names in the index, if any: the
+   * written spelling first, then its final segment, and either reading must
+   * name exactly one element.
+   */
+  uniqueCandidate(name) {
+    return this.lookup?.uniqueForPath(name, (description) => CALLABLE_TYPES.has(description.type));
+  }
+  /** The callable declaration `name` invokes in `document`, resolved locally. */
+  findLocal(document, name) {
+    const root3 = document.parseResult?.value;
+    if (!root3)
+      return void 0;
+    return collectCallables([root3, ...ast_utils_exports.streamAllContents(root3).toArray()]).get(unquoteName3(simpleNameOf2(name)));
+  }
+  /**
+   * SYNCHRONOUS resolution: a qualified spelling the index holds verbatim,
+   * then the document's own tree, then an unambiguous indexed callable —
+   * resolved through the linker's off-to-the-side library parse. Nothing here
+   * grows `LangiumDocuments`, and nothing here awaits, so it is safe on a
+   * request VS Code re-issues on every scroll.
+   */
+  resolve(document, name, local) {
+    if (name.includes("::") || name.includes(".")) {
+      const exact = this.lookup?.unique(name, (description) => CALLABLE_TYPES.has(description.type));
+      const node = exact ? this.nodeOf(exact) : void 0;
+      if (node)
+        return node;
+    }
+    const found = local ? local(unquoteName3(simpleNameOf2(name))) : this.findLocal(document, name);
+    if (found)
+      return found;
+    const candidate = this.uniqueCandidate(name);
+    return candidate ? this.nodeOf(candidate) : void 0;
+  }
+  /** An indexed description as a node, through the linker's lazy library parse. */
+  nodeOf(description) {
+    return this.linker?.resolveIndexedNode?.(description) ?? description.node;
+  }
+  /**
+   * Resolution that may load a workspace document. Signature help uses it: it
+   * runs on an explicit editor gesture, not on every scroll, and a callable in
+   * a workspace file the user has not opened yet still deserves a signature.
+   */
+  // REQ-263 — Signature help on `(` / `,` / `->`
+  async resolveAsync(document, name) {
+    const direct = this.resolve(document, name);
+    if (direct)
+      return direct;
+    const candidate = this.candidates(name).at(0);
+    if (!candidate)
+      return void 0;
+    if (candidate.node)
+      return candidate.node;
+    const documents = this.services?.shared.workspace.LangiumDocuments;
+    const locator = this.services?.workspace.AstNodeLocator;
+    if (!documents || !locator)
+      return void 0;
+    const doc = documents.getDocument(candidate.documentUri) ?? await documents.getOrCreateDocument(candidate.documentUri);
+    const root3 = doc?.parseResult?.value;
+    return root3 ? locator.getAstNode(root3, candidate.path) : void 0;
+  }
+  /** {@link callableParameters} — the parameters, in written order. */
+  parameters(node) {
+    return callableParameters(node);
+  }
+  /**
+   * The parameters a positional argument list binds to: the INPUTS, in written
+   * order. An `out` parameter and the result are not written at the call site
+   * (OMG KerML v1.0 binds an `InvocationExpression`'s arguments to the
+   * invoked type's input features).
+   */
+  inputParameters(node) {
+    return this.parameters(node).filter((parameter) => !parameter.isReturn && parameter.direction !== "out");
+  }
+};
+function callableParameters(node) {
+  const directed = new Map(directedParameters(node).map((entry) => [entry.node, entry.direction]));
+  const result = [];
+  for (const member of membersOf(node)) {
+    const direction = directed.get(member);
+    const isReturn = member.$type === "ReturnDecl";
+    if (!direction && !isReturn)
+      continue;
+    const name = nodeName2(member);
+    if (!name && !direction)
+      continue;
+    result.push({
+      node: member,
+      direction: direction ?? "return",
+      name,
+      type: typingText(member),
+      multiplicity: multiplicityText(member),
+      isReturn
+    });
+  }
+  return result;
+}
+function collectCallables(nodes) {
+  const callables = /* @__PURE__ */ new Map();
+  const byDefinition = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (!CALLABLE_TYPES.has(node.$type) && callableParameters(node).length === 0)
+      continue;
+    const isDefinition = node.isDef === true;
+    for (const name of [nodeName2(node), shortNameOf2(node)]) {
+      if (!name)
+        continue;
+      if (callables.has(name) && !(isDefinition && !byDefinition.has(name)))
+        continue;
+      callables.set(name, node);
+      if (isDefinition)
+        byDefinition.add(name);
+    }
+  }
+  return callables;
+}
+function membersOf(node) {
+  const members = node?.members;
+  return Array.isArray(members) ? members.filter(isAstNode3) : [];
+}
+function isAstNode3(value) {
+  return typeof value === "object" && value !== null && typeof value.$type === "string";
+}
+function nodeName2(node) {
+  const value = node?.name;
+  return typeof value === "string" && value.length > 0 ? unquoteName3(value) : void 0;
+}
+function shortNameOf2(node) {
+  const value = node?.shortName?.name;
+  return typeof value === "string" && value.length > 0 ? unquoteName3(value) : void 0;
+}
+function typingText(node) {
+  const text = node?.typing?.type?.$refText;
+  return typeof text === "string" && text.length > 0 ? text : void 0;
+}
+function multiplicityText(node) {
+  const text = node?.multiplicity?.$cstNode?.text;
+  return typeof text === "string" && text.length > 0 ? text.trim() : void 0;
+}
+
+// ../language-server/out/src/services/inlay-hint-provider.js
 function multiplicityAnchor(node) {
   const leaves = cst_utils_exports.flattenCst(node).toArray();
   const bodyStart = leaves.find((leaf) => leaf.text === "{");
@@ -70031,6 +70356,50 @@ var EXPLICIT_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
   "conjugates"
 ]);
 var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var CONSTANT_CARRYING_KINDS = /* @__PURE__ */ new Set([
+  ":>",
+  "subsets",
+  ":>>",
+  "redefines",
+  "::>",
+  "references",
+  "=>",
+  "crosses"
+]);
+var CONSTANT_MODIFIERS = /* @__PURE__ */ new Set(["constant", "const"]);
+function constantKeyword(languageId) {
+  return languageId === "kerml" ? "const" : "constant";
+}
+var PREFIXES_BEFORE_CONSTANT = /* @__PURE__ */ new Set([
+  "public",
+  "private",
+  "protected",
+  "in",
+  "out",
+  "inout",
+  "abstract",
+  "variation",
+  "variant",
+  "derived",
+  "readonly",
+  "composite",
+  "portion",
+  "ordered",
+  "nonunique",
+  "parallel"
+]);
+var PORTION_MODIFIERS = /* @__PURE__ */ new Set(["portion", "snapshot", "timeslice"]);
+var ACTION_KIND_USAGES = /* @__PURE__ */ new Set([
+  "ActionDecl",
+  "StateDecl",
+  "CalcDecl",
+  "CaseDecl",
+  "UseCaseDecl",
+  "AnalysisCaseDecl",
+  "VerificationCaseDecl"
+]);
+var KERML_FEATURE_DECLS = /* @__PURE__ */ new Set(["FeatureDecl", "StepDecl", "ExpressionDecl"]);
+var REFERENCE_MODIFIERS = /* @__PURE__ */ new Set(["ref", "in", "out", "inout"]);
 var IMPLICIT_BASES = Object.freeze({
   PartDecl: { def: "Parts::Part", usage: "Parts::parts" },
   ItemDecl: { def: "Items::Item", usage: "Items::items" },
@@ -70055,6 +70424,37 @@ var IMPLICIT_BASES = Object.freeze({
   OccurrenceDecl: { def: "Occurrences::Occurrence", usage: "Occurrences::occurrences" },
   MetadataDecl: { def: "Metadata::MetadataItem", usage: "Metadata::metadataItems" }
 });
+var OCCURRENCE_KIND_OWNERS = /* @__PURE__ */ new Set([
+  ...Object.keys(IMPLICIT_BASES).filter((kind) => kind !== "AttributeDecl"),
+  // KerML fixes a library base per classifier kind too, in the same way and in
+  // the same normative place: `Class` specializes `Occurrences::Occurrence`,
+  // `Structure` specializes `Objects::Object`, `Metaclass` specializes
+  // `Metaobjects::Metaobject`, `Behavior` specializes
+  // `Performances::Performance`, `Function` and `Interaction` are Behaviors,
+  // `Predicate` is a Function, `Step` specializes `Performances::performances`
+  // and `Expression` is a Step. All of them reach `Occurrence`.
+  "ClassDecl",
+  "StructDecl",
+  "MetaclassDecl",
+  "BehaviorDecl",
+  "InteractionDecl",
+  "FunctionDecl",
+  "PredicateDecl",
+  "StepDecl",
+  "ExpressionDecl"
+  // Left out because their base is NOT an occurrence: `DatatypeDecl`
+  // (`Base::DataValue`, declared disjoint from `Occurrence`) and plain
+  // `AssociationDecl` (`Links::Link`, which specializes `Base::Anything`) —
+  // `assoc struct` is handled separately, since it is a `LinkObject`.
+  // Left out because their base is WRITTEN rather than fixed by the kind:
+  // `TypeDecl`, `ClassifierDecl`, `FeatureDecl`.
+]);
+function isOccurrenceKindOwner(owner) {
+  if (owner.$type === "AssociationDecl")
+    return owner.isStruct === true;
+  return OCCURRENCE_KIND_OWNERS.has(owner.$type);
+}
+var NON_VARYING_LIBRARY_TYPES = /* @__PURE__ */ new Set(["SelfLink", "HappensLink"]);
 function markdown(value) {
   return { kind: import_vscode_languageserver20.MarkupKind.Markdown, value };
 }
@@ -70076,19 +70476,130 @@ function descriptionRange(description) {
   const segment = description.nameSegment ?? description.selectionSegment;
   return segment?.range ?? { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
 }
+function descriptionLocation(description) {
+  return { uri: description.documentUri.toString(), range: descriptionRange(description) };
+}
+function nodeLocation(node) {
+  const range = node.$cstNode?.range;
+  if (!range)
+    return void 0;
+  return { uri: ast_utils_exports.getDocument(node).uri.toString(), range };
+}
+function specializesNonVaryingLibraryType(node) {
+  const typing = node.typing?.type?.$refText;
+  if (typing && NON_VARYING_LIBRARY_TYPES.has(lastSegment3(typing)))
+    return true;
+  return allRelationships2(node).flatMap((rel) => rel.targets ?? []).some((target) => NON_VARYING_LIBRARY_TYPES.has(lastSegment3(target)));
+}
+function constantAnchor(node) {
+  const cst = node.$cstNode;
+  if (!cst)
+    return void 0;
+  for (const leaf of cst_utils_exports.flattenCst(cst)) {
+    if (leaf.hidden)
+      continue;
+    if (PREFIXES_BEFORE_CONSTANT.has(leaf.text))
+      continue;
+    return /^[a-z]+$/u.test(leaf.text) ? leaf : void 0;
+  }
+  return void 0;
+}
+function membershipImportPath(node) {
+  if (isImport(node) && node.alias)
+    return void 0;
+  if (isExposePath(node) && node.dotSegs.length > 0)
+    return void 0;
+  if (node.segs.some((seg) => seg.star || seg.recursive || !seg.name))
+    return void 0;
+  const last2 = node.segs.at(-1);
+  const written = last2?.name ?? node.head;
+  const anchor = last2 ? grammar_utils_exports.findNodeForProperty(last2.$cstNode, "name") : grammar_utils_exports.findNodeForProperty(node.$cstNode, "head");
+  if (!anchor)
+    return void 0;
+  return { path: [node.head, ...node.segs.map((seg) => seg.name)].join("::"), written, anchor };
+}
+function publicFeatures(type) {
+  const members = type.members;
+  if (!Array.isArray(members))
+    return [];
+  return members.filter((member) => {
+    if (typeof member?.$type !== "string")
+      return false;
+    const decl = member;
+    if (decl.isDef !== false && decl.$type !== "FeatureDecl")
+      return false;
+    return decl.visibility === void 0 || decl.visibility === "public";
+  });
+}
+function calleeName(node) {
+  if (node.call) {
+    if (isPathExpr(node.target))
+      return node.target.path;
+    const target = node.target;
+    if (isPostfixOp(target) && target.dot && target.field)
+      return target.field;
+    return void 0;
+  }
+  if (node.arrow && node.invoke)
+    return node.invoke;
+  return void 0;
+}
+function callArguments(node) {
+  if (node.call)
+    return { args: node.callArgs, firstParameter: 0 };
+  if (node.arrow && node.invoke)
+    return { args: node.args, firstParameter: 1 };
+  return void 0;
+}
 var SysmlInlayHintProvider = class {
   services;
   /**
    * Resolved implicit bases, keyed by the qualified name in
-   * {@link IMPLICIT_BASES}. The standard library does not change once it is
-   * loaded, so this is built at most once for real; while it is still empty —
-   * before the library has been indexed — the rebuild is over a tiny index and
-   * costs nothing, which is what keeps the hint path free of a full index scan
-   * on every request.
+   * {@link IMPLICIT_BASES}. A base the index does not hold is NOT cached — the
+   * library may still be loading — and issue #240 made that miss cheap: two
+   * lookups in the shared name index rather than the full index scan it used
+   * to be, on a request VS Code re-issues on every scroll. A HIT is cached
+   * until the index is rebuilt, so the description a label links to always
+   * carries the ranges of the generation it was read from.
    */
   baseCache = /* @__PURE__ */ new Map();
+  /**
+   * REQ-395 — issue #240: the shared name lookup, built once per index
+   * generation. Every category that resolves a WRITTEN name goes through it,
+   * so no request puts an index scan on the hint path.
+   */
+  lookup;
+  /** REQ-395 — issue #240: the callee resolution signature help also uses. */
+  callables;
+  /** REQ-395 — issue #240: the linker's lazy standard-library parse. */
+  linker;
+  /**
+   * REQ-395 — issue #240: "does this element declare `constant`?", memoized by
+   * element identity, because answering it may cost one lazily parsed library
+   * file. Editing away the `constant` on the SUBSETTED feature changes the
+   * answer without changing the key, so this is dropped whenever the index is
+   * rebuilt, exactly like the shared name lookup.
+   */
+  constantCache = /* @__PURE__ */ new Map();
+  /**
+   * REQ-395 — issue #240: an element's own written names, memoized by element
+   * identity. Reading them tells a `<short>` name from a regular one, which is
+   * what lets the imported-name hint print the notation the source would have
+   * written. It costs at most one lazily parsed library file, only for an
+   * element that actually has two names, and it is dropped with the rest when
+   * the index is rebuilt.
+   */
+  declaredNameCache = /* @__PURE__ */ new Map();
   constructor(services) {
     this.services = services;
+    this.lookup = nameLookupFor(services?.shared);
+    this.callables = new CallableResolver(services);
+    this.linker = services?.references.Linker;
+    services?.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
+      this.baseCache.clear();
+      this.constantCache.clear();
+      this.declaredNameCache.clear();
+    });
   }
   getInlayHints(document, _params) {
     const root3 = document.parseResult?.value;
@@ -70096,7 +70607,14 @@ var SysmlInlayHintProvider = class {
       return void 0;
     const settings = sysmlInlayHintSettings;
     const hints = [];
-    for (const node of allAstNodes(root3)) {
+    const nodes = allAstNodes(root3);
+    let localCallables;
+    const localCallable = (simple) => {
+      localCallables ??= collectCallables(nodes);
+      return localCallables.get(simple);
+    };
+    const callees = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
       const decl = node;
       if (settings.multiplicity && (isPartDecl(node) || isPortDecl(node) || isAttributeDecl(node)) && !decl.isDef && !decl.multiplicity && node.$cstNode && decl.name) {
         hints.push({
@@ -70123,6 +70641,11 @@ var SysmlInlayHintProvider = class {
           });
         }
       }
+      if (settings.modifiers) {
+        const constant2 = this.implicitConstantHint(decl);
+        if (constant2)
+          hints.push(constant2);
+      }
       if (settings.modifiers && isAttributeDecl(node) && !decl.isDef && !(decl.modifiers ?? []).includes("ref")) {
         const keyword = keywordLeaf(node, "attribute");
         if (keyword) {
@@ -70164,6 +70687,17 @@ var SysmlInlayHintProvider = class {
         if (effective)
           hints.push(effective);
       }
+      if (settings.importedNames && (isImport(node) || isExposePath(node))) {
+        const imported = this.importedNameHint(node);
+        if (imported)
+          hints.push(imported);
+      }
+      if (settings.parameterNames && isPostfixOp(node)) {
+        hints.push(...this.argumentNameHints(node, document, callees, localCallable));
+      }
+      if (settings.parameterNames && isNewExpr(node)) {
+        hints.push(...this.constructorArgumentHints(node));
+      }
       if (!settings.dimension)
         continue;
       if (isNumericPrimary(node)) {
@@ -70233,6 +70767,228 @@ var SysmlInlayHintProvider = class {
     }
     return hints;
   }
+  /**
+   * REQ-395 — issue #240: the other name a membership `import` brings in.
+   *
+   * An element may declare both a regular name and a `<short>` name, and an
+   * import brings in BOTH — the one the path does not write is invisible in
+   * the source, which is exactly what the hint is for. The written path is a
+   * datatype string, not a cross-reference, so the element is found through
+   * the shared name lookup: the spelling the index holds verbatim first, then
+   * the final segment, and either reading must name exactly ONE element. A
+   * name two packages both declare yields nothing rather than whichever the
+   * index lists first.
+   */
+  importedNameHint(node) {
+    const written = membershipImportPath(node);
+    if (!written || !this.lookup)
+      return void 0;
+    const description = this.lookup.uniqueForPath(written.path);
+    if (!description)
+      return void 0;
+    const others = this.lookup.otherNames(description, written.written);
+    if (others.length === 0)
+      return void 0;
+    const declared = this.declaredNames(description);
+    const shown = others.map((name) => declared?.shortName === name ? `<${name}>` : name);
+    const kind = isImport(node) ? "import" : "expose";
+    return {
+      position: written.anchor.range.end,
+      label: [{
+        value: ` also ${shown.join(", ")}`,
+        location: descriptionLocation(description)
+      }],
+      kind: import_vscode_languageserver20.InlayHintKind.Parameter,
+      paddingLeft: true,
+      tooltip: markdown(`This \`${kind}\` also brings \`${shown.join("`, `")}\` into scope: an element is addressable by its regular name and by its short name, and a membership import carries both.`)
+    };
+  }
+  /**
+   * REQ-395 — issue #240: the names an indexed element declares for itself.
+   *
+   * The index records the spellings but not which of them is the `<short>`
+   * one, so the declaration is resolved through the linker's off-to-the-side
+   * library parse — the budget REQ-251 sets, spent only for an element that
+   * has more than one name, and memoized until the index is rebuilt.
+   */
+  declaredNames(description) {
+    const key = elementKey2(description);
+    const cached = this.declaredNameCache.get(key);
+    if (cached)
+      return cached;
+    const node = this.linker?.resolveIndexedNode?.(description) ?? description.node;
+    if (!node)
+      return void 0;
+    const decl = node;
+    const names = { name: decl.name, shortName: decl.shortName?.name };
+    this.declaredNameCache.set(key, names);
+    return names;
+  }
+  /**
+   * REQ-395 — issue #240: the feature each `new Type(…)` argument binds to.
+   *
+   * A `ConstructorExpression` binds its arguments to the PUBLIC features of
+   * the instantiated type, in order (OMG KerML v1.0, `ConstructorExpression`)
+   * — not to input parameters, which is what an `InvocationExpression` binds.
+   * The instantiated type IS a cross-reference here, so there is nothing to
+   * resolve by name: an unresolved one simply yields no hints.
+   */
+  constructorArgumentHints(node) {
+    if (node.args.length === 0)
+      return [];
+    if (node.args.every((argument) => argument.name !== void 0))
+      return [];
+    const instantiated = node.type?.ref;
+    if (!instantiated)
+      return [];
+    const features = publicFeatures(instantiated);
+    if (features.length === 0)
+      return [];
+    const hints = [];
+    for (let index = 0; index < node.args.length; index++) {
+      const argument = node.args[index];
+      if (argument.name || !argument.$cstNode)
+        continue;
+      const feature = features[index];
+      const name = feature?.name;
+      if (!feature || !name)
+        continue;
+      const location = nodeLocation(feature);
+      hints.push({
+        position: argument.$cstNode.range.start,
+        label: [{ value: `${name} =`, ...location ? { location } : {} }],
+        kind: import_vscode_languageserver20.InlayHintKind.Parameter,
+        paddingRight: true,
+        tooltip: markdown(`Argument ${index + 1} binds to \`${name}\` of \`${node.type.$refText}\`.`)
+      });
+    }
+    return hints;
+  }
+  /**
+   * REQ-395 — issue #240: the parameter a POSITIONAL invocation argument binds
+   * to.
+   *
+   * The callee of a call is an expression rather than a cross-reference, so
+   * the name is resolved through the shared {@link CallableResolver} — the
+   * same one signature help uses, which is why naming these arguments does not
+   * add a second resolution path. An argument that writes its own name has
+   * stated the correspondence, so it gets no hint.
+   */
+  argumentNameHints(node, document, callees, localCallable) {
+    const call = callArguments(node);
+    const callee = calleeName(node);
+    if (!call || !callee || call.args.length === 0)
+      return [];
+    if (call.args.every((argument) => argument.argName !== void 0))
+      return [];
+    let callable = callees.get(callee);
+    if (callable === void 0 && !callees.has(callee)) {
+      callable = this.callables.resolve(document, callee, localCallable);
+      callees.set(callee, callable);
+    }
+    if (!callable)
+      return [];
+    const parameters = this.callables.inputParameters(callable);
+    if (parameters.length === 0)
+      return [];
+    const hints = [];
+    for (let index = 0; index < call.args.length; index++) {
+      const argument = call.args[index];
+      if (argument.argName || !argument.$cstNode)
+        continue;
+      const parameter = parameters[index + call.firstParameter];
+      if (!parameter?.name)
+        continue;
+      const location = nodeLocation(parameter.node);
+      hints.push({
+        position: argument.$cstNode.range.start,
+        label: [{ value: `${parameter.name} =`, ...location ? { location } : {} }],
+        kind: import_vscode_languageserver20.InlayHintKind.Parameter,
+        paddingRight: true,
+        tooltip: markdown(`Argument ${index + 1} binds to \`${parameter.direction} ${parameter.name}\` of \`${callee}\`.`)
+      });
+    }
+    return hints;
+  }
+  /**
+   * REQ-395 — issue #240: implicit `constant`.
+   *
+   * OMG KerML v1.0 constrains `Subsetting`: `subsettedFeature.isConstant and
+   * subsettingFeature.isVariable implies subsettingFeature.isConstant`. So a
+   * usage that subsets or redefines a feature declared `constant` IS constant,
+   * without writing it — provided it can vary at all, because `Feature` also
+   * constrains `isConstant implies isVariable`.
+   *
+   * Whether it can vary is `Usage::mayTimeVary`, which OMG SysML v2 Part 1
+   * derives as "owned by a type that specializes `Occurrences::Occurrence`,
+   * and not a portion, a self/happens link, or a composite action". All four
+   * are decided here from the declaration kinds and what the source writes
+   * ({@link isOccurrenceKindOwner}, {@link PORTION_MODIFIERS},
+   * {@link ACTION_KIND_USAGES} with {@link REFERENCE_MODIFIERS}, and
+   * {@link specializesNonVaryingLibraryType}); an owner whose base is written
+   * rather than fixed by its kind leaves the category quiet, as an
+   * undecidable model must.
+   */
+  implicitConstantHint(node) {
+    const isFeature = node.isDef === false || KERML_FEATURE_DECLS.has(node.$type);
+    if (!isFeature)
+      return void 0;
+    const modifiers2 = node.modifiers ?? [];
+    if (modifiers2.some((modifier) => CONSTANT_MODIFIERS.has(modifier)))
+      return void 0;
+    if (modifiers2.some((modifier) => PORTION_MODIFIERS.has(modifier)))
+      return void 0;
+    if (ACTION_KIND_USAGES.has(node.$type) && !modifiers2.some((modifier) => REFERENCE_MODIFIERS.has(modifier)))
+      return void 0;
+    const owner = node.$container;
+    if (!owner || !isOccurrenceKindOwner(owner))
+      return void 0;
+    if (specializesNonVaryingLibraryType(node))
+      return void 0;
+    const carrier = allRelationships2(node).filter((rel) => rel.kind && CONSTANT_CARRYING_KINDS.has(rel.kind)).flatMap((rel) => rel.targets ?? []).find((target) => this.isConstantFeature(target));
+    if (!carrier)
+      return void 0;
+    const anchor = constantAnchor(node);
+    const at = anchor?.range.start ?? node.$cstNode?.range.start;
+    if (!at)
+      return void 0;
+    const keyword = constantKeyword(this.services?.LanguageMetaData.languageId);
+    return {
+      position: at,
+      label: keyword,
+      kind: import_vscode_languageserver20.InlayHintKind.Type,
+      paddingRight: true,
+      tooltip: markdown(`Implicitly \`${keyword}\`: this feature subsets \`${lastSegment3(carrier)}\`, which is declared constant, and a subsetting feature that may vary takes the constancy of what it subsets.`),
+      // Writing the modifier is mechanically safe — it is a leading
+      // declaration prefix, and OMG puts it exactly here, before `ref`
+      // and the kind keyword.
+      ...anchor ? { textEdits: [{ range: { start: at, end: at }, newText: `${keyword} ` }] } : {}
+    };
+  }
+  /**
+   * REQ-395 — issue #240: does the feature this path names declare `constant`?
+   *
+   * The path must name exactly one element, and that element is resolved
+   * through the linker's off-to-the-side library parse — one lazily parsed
+   * indexed target, the budget REQ-251 sets, and never a document added to the
+   * workspace. The answer is memoized, so a scroll does not repeat it.
+   */
+  isConstantFeature(target) {
+    if (!this.lookup)
+      return false;
+    const description = this.lookup.uniqueForPath(target);
+    if (!description)
+      return false;
+    const key = elementKey2(description);
+    const cached = this.constantCache.get(key);
+    if (cached !== void 0)
+      return cached;
+    const node = this.linker?.resolveIndexedNode?.(description) ?? description.node;
+    const modifiers2 = node?.modifiers ?? [];
+    const answer = modifiers2.some((modifier) => CONSTANT_MODIFIERS.has(modifier));
+    this.constantCache.set(key, answer);
+    return answer;
+  }
   /**
    * REQ-395 — Find one implicit base in the index.
    *
@@ -70246,25 +71002,19 @@ var SysmlInlayHintProvider = class {
     const cached = this.baseCache.get(qualified);
     if (cached)
       return cached;
-    const index = this.services?.shared.workspace.IndexManager;
-    if (!index)
+    if (!this.lookup)
       return void 0;
-    const simple = lastSegment3(qualified);
-    let fallback;
-    for (const description of index.allElements()) {
-      if (description.name === qualified) {
-        this.baseCache.set(qualified, description);
-        return description;
-      }
-      if (fallback || description.name !== simple)
-        continue;
+    const exact = this.lookup.descriptions(qualified).at(0);
+    if (exact) {
+      this.baseCache.set(qualified, exact);
+      return exact;
+    }
+    const fallback = this.lookup.descriptions(lastSegment3(qualified)).find((description) => {
       const uri = description.documentUri instanceof URI2 ? description.documentUri : URI2.parse(String(description.documentUri));
       if (!isStandardLibraryUri(uri))
-        continue;
-      if (description.isUsage === true !== wantUsage)
-        continue;
-      fallback = description;
-    }
+        return false;
+      return description.isUsage === true === wantUsage;
+    });
     if (fallback)
       this.baseCache.set(qualified, fallback);
     return fallback;
@@ -72319,7 +73069,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.24.0" : "dev";
+var VERSION2 = true ? "0.26.0" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {