sysml-v2-lsp 0.40.0 → 0.41.0

package/dist/server/server.js

@@ -121790,7 +121790,10 @@ function splitQualifiedName(text) {
   return parts;
 }
 function joinQualifiedName(parts) {
-  return parts.map((part) => /::|['\\\r\n\t\b\f]|^\s|\s$/.test(part) ? quoteName(part) : part).join("::");
+  return parts.map((part) => /::|^:|:$|['\\\r\n\t\b\f]|^\s|\s$|^\$?$/.test(part) ? quoteName(part) : part).join("::");
+}
+function joinReference(chain, conjugated = false) {
+  return (conjugated ? "~" : "") + chain.map(({ global, names }) => (global ? "$::" : "") + names.map((name) => /\.|^~/.test(name) ? quoteName(name) : joinQualifiedName([name])).join("::")).join(".");
 }
 function readNameAt(text, start, allowIncomplete = false) {
   if (text[start] === "'") {
@@ -123160,12 +123163,44 @@ var RULE_INDEX_TO_KIND = /* @__PURE__ */ new Map([
 var BODY_RULE_INDICES = new Set(
   SysMLv2Parser.ruleNames.flatMap((ruleName, index2) => ruleName.endsWith("Body") ? [index2] : [])
 );
+var VALUE_DECLARATION_RULE_INDICES = /* @__PURE__ */ new Set([
+  SysMLv2Parser.RULE_usage,
+  SysMLv2Parser.RULE_usageCompletion,
+  SysMLv2Parser.RULE_actionUsageDeclaration,
+  SysMLv2Parser.RULE_performActionUsageDeclaration,
+  SysMLv2Parser.RULE_constraintUsageDeclaration,
+  SysMLv2Parser.RULE_interfaceUsageDeclaration,
+  SysMLv2Parser.RULE_flowDeclaration,
+  SysMLv2Parser.RULE_messageDeclaration
+]);
 var FLOW_PART_RULE_INDICES = /* @__PURE__ */ new Set([
   SysMLv2Parser.RULE_payloadFeatureMember,
   SysMLv2Parser.RULE_flowPayloadFeatureMember,
   SysMLv2Parser.RULE_flowEndMember,
   SysMLv2Parser.RULE_messageEventMember
 ]);
+var SPECIALIZATION_DECLARATION_RULE_INDICES = /* @__PURE__ */ new Set([
+  SysMLv2Parser.RULE_definition,
+  SysMLv2Parser.RULE_definitionDeclaration,
+  SysMLv2Parser.RULE_usage,
+  SysMLv2Parser.RULE_usageDeclaration,
+  SysMLv2Parser.RULE_featureDeclaration,
+  SysMLv2Parser.RULE_featureSpecializationPart,
+  SysMLv2Parser.RULE_actionUsageDeclaration,
+  SysMLv2Parser.RULE_performActionUsageDeclaration,
+  SysMLv2Parser.RULE_constraintUsageDeclaration,
+  SysMLv2Parser.RULE_interfaceUsageDeclaration,
+  SysMLv2Parser.RULE_allocationUsageDeclaration,
+  SysMLv2Parser.RULE_flowDeclaration,
+  SysMLv2Parser.RULE_messageDeclaration
+]);
+var REFERENCE_SHORTHAND_RULE_INDICES = /* @__PURE__ */ new Set([
+  SysMLv2Parser.RULE_variantReference,
+  SysMLv2Parser.RULE_performActionUsageDeclaration,
+  SysMLv2Parser.RULE_exhibitStateUsage,
+  SysMLv2Parser.RULE_framedConcernUsage,
+  SysMLv2Parser.RULE_includeUseCaseUsage
+]);
 var FLOW_DECLARATION_RULE_INDICES = [
   SysMLv2Parser.RULE_flowDeclaration,
   SysMLv2Parser.RULE_messageDeclaration
@@ -123271,6 +123306,50 @@ var PREFIX_EXTENSION_RULE_INDICES = /* @__PURE__ */ new Set([
   SysMLv2Parser.RULE_endFeaturePrefix
   // 86
 ]);
+var PREFIX_KEYWORD_TOKENS = /* @__PURE__ */ new Set([
+  SysMLv2Lexer.IN,
+  SysMLv2Lexer.OUT,
+  SysMLv2Lexer.INOUT,
+  SysMLv2Lexer.ABSTRACT,
+  SysMLv2Lexer.VARIATION,
+  SysMLv2Lexer.INDIVIDUAL,
+  SysMLv2Lexer.DERIVED,
+  SysMLv2Lexer.CONSTANT,
+  SysMLv2Lexer.REF,
+  SysMLv2Lexer.END,
+  SysMLv2Lexer.ORDERED,
+  SysMLv2Lexer.NONUNIQUE
+]);
+var PREFIX_PATH_RULE_INDICES = /* @__PURE__ */ new Set([
+  SysMLv2Parser.RULE_usagePrefix,
+  SysMLv2Parser.RULE_unextendedUsagePrefix,
+  SysMLv2Parser.RULE_basicUsagePrefix,
+  SysMLv2Parser.RULE_endUsagePrefix,
+  SysMLv2Parser.RULE_refPrefix,
+  SysMLv2Parser.RULE_featureDirection,
+  SysMLv2Parser.RULE_occurrenceUsagePrefix,
+  SysMLv2Parser.RULE_controlNodePrefix,
+  SysMLv2Parser.RULE_definitionPrefix,
+  SysMLv2Parser.RULE_basicDefinitionPrefix,
+  SysMLv2Parser.RULE_occurrenceDefinitionPrefix,
+  SysMLv2Parser.RULE_usage,
+  SysMLv2Parser.RULE_usageDeclaration,
+  SysMLv2Parser.RULE_featureDeclaration,
+  SysMLv2Parser.RULE_featureSpecializationPart,
+  SysMLv2Parser.RULE_multiplicityPart,
+  SysMLv2Parser.RULE_actionUsageDeclaration,
+  SysMLv2Parser.RULE_performActionUsageDeclaration,
+  SysMLv2Parser.RULE_constraintUsageDeclaration,
+  SysMLv2Parser.RULE_interfaceUsageDeclaration,
+  SysMLv2Parser.RULE_allocationUsageDeclaration,
+  SysMLv2Parser.RULE_flowDeclaration,
+  SysMLv2Parser.RULE_messageDeclaration
+]);
+var OCCURRENCE_USAGE_ELEMENT_RULE_INDICES = /* @__PURE__ */ new Set([
+  SysMLv2Parser.RULE_occurrenceUsageElement,
+  SysMLv2Parser.RULE_structureUsageElement,
+  SysMLv2Parser.RULE_behaviorUsageElement
+]);
 var TYPE_SPECIALIZATION_RULE_INDICES = /* @__PURE__ */ new Set([
   SysMLv2Parser.RULE_specialization,
   // 66
@@ -124105,6 +124184,9 @@ var SymbolTable = class {
     const typeName = typeNames[0];
     const documentation = this.extractDocumentation(ctx);
     const visibility = this.extractVisibility(ctx);
+    const featureValue = this.extractFeatureValue(ctx);
+    const prefixKeywords = this.extractPrefixKeywords(ctx);
+    const ownedSpecializations = this.extractOwnedSpecializations(ctx);
     const { multiplicity, multiplicityRange } = isUsage(kind) ? this.extractMultiplicity(ctx) : {};
     const metadataAnnotations = this.extractPrefixMetadataAnnotations(ctx);
     const isView = kind === "view" /* ViewUsage */ || kind === "view def" /* ViewDef */;
@@ -124137,6 +124219,9 @@ var SymbolTable = class {
       namingReference,
       documentation,
       visibility,
+      featureValue,
+      prefixKeywords: prefixKeywords.length > 0 ? prefixKeywords : void 0,
+      ownedSpecializations: ownedSpecializations.length > 0 ? ownedSpecializations : void 0,
       source: transition?.source,
       target: transition?.target,
       flowDetails,
@@ -124520,7 +124605,23 @@ var SymbolTable = class {
    * between two of them (`connect a.p to b.p`, `connection : Conn`).
    */
   declarationText(ctx) {
-    const tokens = this.declarationTokens(ctx);
+    return this.tokensText(this.declarationTokens(ctx));
+  }
+  /** Every token of `ctx`, in source order: a whole expression, bodies and `;` included. */
+  subtreeTokens(ctx, tokens = []) {
+    for (let i = 0; i < ctx.getChildCount(); i++) {
+      const child = ctx.getChild(i);
+      if (child instanceof TerminalNode) {
+        if (child.symbol.tokenIndex >= 0) tokens.push(child.symbol);
+      } else if (child instanceof ParserRuleContext) this.subtreeTokens(child, tokens);
+    }
+    return tokens;
+  }
+  /**
+   * Tokens joined as written, with one space wherever the source has
+   * whitespace or a comment between two of them.
+   */
+  tokensText(tokens) {
     let text = "";
     tokens.forEach((token, i) => {
       if (i > 0 && token.start > tokens[i - 1].stop + 1) text += " ";
@@ -124626,6 +124727,139 @@ var SymbolTable = class {
     }
     return void 0;
   }
+  /**
+   * `ctx`'s own feature value (SysML 7.13.4, 8.2.2.6.2 `ValuePart`, `FeatureValue`):
+   * its expression as written, and whether it is a default (`default`) and an
+   * initial (`:=`) value. Never a nested element's value; a cross subsetting
+   * (`=> x`) is not a value. The expression is the whole `OwnedExpression`,
+   * expression bodies included, with whitespace and comments as one space.
+   */
+  extractFeatureValue(ctx) {
+    const featureValueCtx = this.findOwnValuePart(ctx)?.getRuleContext(0, FeatureValueContext);
+    const expression = featureValueCtx?.ownedExpression();
+    const text = expression && this.tokensText(this.subtreeTokens(expression));
+    if (!featureValueCtx || !text) return void 0;
+    return {
+      expression: text,
+      isDefault: featureValueCtx.DEFAULT() !== null,
+      isInitial: featureValueCtx.COLON_EQ() !== null
+    };
+  }
+  /**
+   * `ctx`'s own `ValuePart`: a direct child of its element rule, or of one of
+   * its declaration rules (`VALUE_DECLARATION_RULE_INDICES`). Never one of an
+   * inline-owned element, e.g. a transition's accept payload or effect action.
+   */
+  findOwnValuePart(ctx) {
+    for (let i = 0; i < ctx.getChildCount(); i++) {
+      const child = ctx.getChild(i);
+      if (!(child instanceof ParserRuleContext)) continue;
+      if (child.ruleIndex === SysMLv2Parser.RULE_valuePart) return child;
+      if (!VALUE_DECLARATION_RULE_INDICES.has(child.ruleIndex)) continue;
+      const valuePart = this.findOwnValuePart(child);
+      if (valuePart) return valuePart;
+    }
+    return void 0;
+  }
+  /**
+   * The specializations of `ctx`'s own declaration, one per target in written
+   * order, read only from its `FeatureSpecialization`s (SysML v2 8.2.2.6.2),
+   * `SubclassificationPart` (8.2.2.6.1) and a shorthand's reference
+   * (`perform a`, `REFERENCE_SHORTHAND_RULE_INDICES`), reached through
+   * `SPECIALIZATION_DECLARATION_RULE_INDICES`.
+   */
+  extractOwnedSpecializations(ctx) {
+    const specializations = [];
+    const add = (kind, targets, notation) => {
+      for (const targetCtx of targets) {
+        const target = targetCtx && this.specializationTarget(targetCtx);
+        if (target) specializations.push(notation ? { kind, target, notation: notation.getText() } : { kind, target });
+      }
+    };
+    const visit = (node) => {
+      for (let i = 0; i < node.getChildCount(); i++) {
+        const child = node.getChild(i);
+        if (child instanceof FeatureSpecializationContext) {
+          const typings = child.typings();
+          const subsettings = child.subsettings();
+          const references = child.references();
+          const crosses = child.crosses();
+          const redefinitions = child.redefinitions();
+          if (typings) {
+            const typedBy = typings.typedBy();
+            add("typing", [typedBy?.featureTyping(), ...typings.featureTyping()].map((typing) => typing && (typing.ownedFeatureTyping() ?? typing.conjugatedPortTyping())));
+          } else if (subsettings) {
+            const subsets = subsettings.subsets();
+            add("subsetting", [subsets?.ownedSubsetting(), ...subsettings.ownedSubsetting()], subsets && (subsets.COLON_GT() ?? subsets.SUBSETS()));
+          } else if (references) {
+            add("referenceSubsetting", [references.ownedReferenceSubsetting()], references.COLON_COLON_GT() ?? references.REFERENCES());
+          } else if (crosses) {
+            add("crossSubsetting", [crosses.ownedCrossSubsetting()], crosses.FAT_ARROW() ?? crosses.CROSSES());
+          } else if (redefinitions) {
+            const redefines = redefinitions.redefines();
+            add("redefinition", [redefines?.ownedRedefinition(), ...redefinitions.ownedRedefinition()], redefines && (redefines.COLON_GT_GT() ?? redefines.REDEFINES()));
+          }
+        } else if (child instanceof OwnedReferenceSubsettingContext && REFERENCE_SHORTHAND_RULE_INDICES.has(node.ruleIndex)) {
+          add("referenceSubsetting", [child]);
+        } else if (child instanceof SubclassificationPartContext) {
+          add("specializes", child.ownedSubclassification(), child.COLON_GT() ?? child.SPECIALIZES());
+        } else if (child instanceof ParserRuleContext && SPECIALIZATION_DECLARATION_RULE_INDICES.has(child.ruleIndex)) {
+          visit(child);
+        }
+      }
+    };
+    visit(ctx);
+    return specializations;
+  }
+  /**
+   * The general type or feature a specialization's target rule names: its
+   * qualified name, or its feature chain (`v.engine`), with a global `$::`
+   * (KerML 7.2.2) and a conjugated port typing's `~` (`~P`, SysML 8.3.12.3).
+   * Its names are quoted as everywhere in the server (`joinReference`).
+   * Undefined for a target missing after a syntax error.
+   */
+  specializationTarget(ctx) {
+    const chain = ctx.getRuleContexts(QualifiedNameContext).map((qualifiedName) => ({
+      global: qualifiedName.DOLLAR() !== null,
+      names: qualifiedName.getRuleContexts(NameContext).map((name) => name.getText())
+    }));
+    if (chain.length === 0 || chain.some(({ names }) => names.length === 0 || names.some((name) => !name))) return void 0;
+    return joinReference(
+      chain.map(({ global, names }) => ({ global, names: names.map(unquoteName) })),
+      ctx instanceof ConjugatedPortTypingContext
+    );
+  }
+  /**
+   * The keywords of `ctx`'s own prefix and multiplicity part, in written
+   * order (`in`, `abstract`, `constant`, `ref`, `end`, `ordered`, ...),
+   * read only from the rules in `PREFIX_PATH_RULE_INDICES`.
+   */
+  extractPrefixKeywords(ctx) {
+    const keywords = [];
+    const visit = (node) => {
+      for (let i = 0; i < node.getChildCount(); i++) {
+        const child = node.getChild(i);
+        if (child instanceof TerminalNode) {
+          if (PREFIX_KEYWORD_TOKENS.has(child.symbol.type)) keywords.push(child.getText());
+          continue;
+        }
+        if (child instanceof ParserRuleContext && PREFIX_PATH_RULE_INDICES.has(child.ruleIndex)) visit(child);
+      }
+    };
+    visit(ctx);
+    return this.isEndOccurrence(ctx) ? ["end", ...keywords] : keywords;
+  }
+  /**
+   * Whether `ctx` is the occurrence usage of an `endOccurrenceUsageElement`
+   * (`end part a`), whose `end` precedes the usage's own rule.
+   */
+  isEndOccurrence(ctx) {
+    let current = ctx.parent;
+    while (current instanceof ParserRuleContext && OCCURRENCE_USAGE_ELEMENT_RULE_INDICES.has(current.ruleIndex)) {
+      current = current.parent;
+    }
+    return current !== ctx.parent && current instanceof ParserRuleContext && current.ruleIndex === SysMLv2Parser.RULE_endOccurrenceUsageElement;
+  }
   /**
    * Extract the range of just the name token.
    */
@@ -126604,22 +126838,6 @@ function readWordAfterKeyword(text, afterPos, allowDots = false) {
   const start = skipWS(text, afterPos);
   return readIdent(text, start, allowDots);
 }
-function readCommaSeparatedIdents(text, pos) {
-  const names = [];
-  let p = skipWS(text, pos);
-  while (p < text.length) {
-    const [name, end] = readIdent(text, p);
-    if (!name) break;
-    names.push(name);
-    p = skipWS(text, end);
-    if (p < text.length && text[p] === ",") {
-      p = skipWS(text, p + 1);
-    } else {
-      break;
-    }
-  }
-  return names;
-}
 function symbolsById(symbols) {
   return new Map(symbols.map((s) => [s.symbolId, s]));
 }
@@ -126665,7 +126883,7 @@ var SysMLModelProvider = class {
       result.activityDiagrams = this.extractActivityDiagrams(symbolTable, uri, lines);
     }
     if (scopeSet.has("resolvedTypes")) {
-      result.resolvedTypes = this.extractResolvedTypes(symbolTable, uri, lines);
+      result.resolvedTypes = this.extractResolvedTypes(symbolTable, uri);
     }
     if (scopeSet.has("diagnostics")) {
       result.diagnostics = this.extractSemanticDiagnostics(symbolTable, uri);
@@ -126764,44 +126982,34 @@ var SysMLModelProvider = class {
     if (symbol.viewRendering) {
       attributes["viewRendering"] = symbol.viewRendering;
     }
-    const direction = this.extractDirection(symbol, lines);
-    if (direction) {
-      attributes["direction"] = direction;
+    const prefix = prefixAttributesOf(symbol);
+    if (prefix.direction) {
+      attributes["direction"] = prefix.direction;
     }
     if (symbol.multiplicity) {
       attributes["multiplicity"] = symbol.multiplicity;
     }
-    const modifier = this.extractModifier(symbol, lines);
-    if (modifier) {
-      attributes["modifier"] = modifier;
+    if (prefix.modifier) {
+      attributes["modifier"] = prefix.modifier;
+    }
+    if (prefix.ordered) {
+      attributes["ordered"] = true;
+    }
+    if (prefix.nonunique) {
+      attributes["nonunique"] = true;
     }
     if (symbol.visibility) {
       attributes["visibility"] = symbol.visibility;
     }
-    const value = this.extractValue(symbol, lines);
-    if (value) {
-      attributes["value"] = value;
+    if (symbol.featureValue) {
+      attributes["value"] = symbol.featureValue.expression;
+      if (symbol.featureValue.isDefault) attributes["isDefault"] = true;
+      if (symbol.featureValue.isInitial) attributes["isInitial"] = true;
     }
     const relationships = [];
-    for (const tn of symbol.typeNames) {
-      relationships.push({
-        type: "typing",
-        source: symbol.name,
-        sourceId: symbol.symbolId,
-        target: tn
-      });
-    }
+    relationships.push(...this.specializationRelationships(symbol));
     const flowRelationship = this.flowRelationship(symbol);
     if (flowRelationship) relationships.push(flowRelationship);
-    const specializations = this.extractSpecializations(symbol, lines);
-    for (const spec of specializations) {
-      relationships.push({
-        type: "specializes",
-        source: symbol.name,
-        sourceId: symbol.symbolId,
-        target: spec
-      });
-    }
     return {
       type: symbol.kind,
       name: symbol.name,
@@ -126813,6 +127021,20 @@ var SysMLModelProvider = class {
       relationships
     };
   }
+  /**
+   * The typings, subclassifications, subsettings and redefinitions of the
+   * element's own declaration, one per target in written order (SysML v2
+   * 8.2.2.6.1, 8.2.2.6.2).
+   */
+  specializationRelationships(symbol) {
+    return (symbol.ownedSpecializations ?? []).map(({ kind, target, notation }) => ({
+      type: kind,
+      source: symbol.name,
+      sourceId: symbol.symbolId,
+      target,
+      ...notation ? { notation } : {}
+    }));
+  }
   flowRelationship(symbol) {
     const details = symbol.flowDetails;
     if (!isFlowUsage(symbol.kind) || !details?.source || !details.target) return void 0;
@@ -126846,25 +127068,7 @@ var SysMLModelProvider = class {
       if (symbol.kind === "package" /* Package */ || symbol.kind === "import" /* Import */ || symbol.kind === "comment" /* Comment */ || symbol.kind === "doc" /* Doc */) {
         continue;
       }
-      if (symbol.typeNames.length > 0 && isUsage(symbol.kind)) {
-        for (const tn of symbol.typeNames) {
-          relationships.push({
-            type: "typing",
-            source: symbol.name,
-            sourceId: symbol.symbolId,
-            target: tn
-          });
-        }
-      }
-      const specializations = this.extractSpecializations(symbol, lines);
-      for (const spec of specializations) {
-        relationships.push({
-          type: "specializes",
-          source: symbol.name,
-          sourceId: symbol.symbolId,
-          target: spec
-        });
-      }
+      relationships.push(...this.specializationRelationships(symbol));
       if (symbol.kind === "connection" /* ConnectionUsage */) {
         const connectionTargets = this.extractConnectionEndpoints(symbol, lines);
         if (connectionTargets.length === 2) {
@@ -127357,41 +127561,30 @@ var SysMLModelProvider = class {
    * Because the LSP server doesn't yet have a full type resolver or library
    * index, we provide what's available from the parse tree.
    */
-  extractResolvedTypes(symbolTable, uri, lines) {
+  extractResolvedTypes(symbolTable, uri) {
     const symbols = symbolTable.getSymbolsForUri(uri);
     const result = {};
     for (const symbol of symbols) {
       const qualifiedName = symbol.qualifiedName;
       if (qualifiedName === void 0) continue;
-      if (!isDefinition(symbol.kind) && symbol.typeNames.length === 0) {
+      if (!isDefinition(symbol.kind) && !symbol.ownedSpecializations) {
         continue;
       }
-      const specializes = [];
-      const specList = this.extractSpecializations(symbol, lines);
-      for (const s of specList) {
-        if (!specializes.includes(s)) {
-          specializes.push(s);
-        }
-      }
-      for (const tn of symbol.typeNames) {
-        if (!specializes.includes(tn)) {
-          specializes.push(tn);
-        }
-      }
+      const specializes = [...new Set((symbol.ownedSpecializations ?? []).map(({ target }) => target))];
       const specializationChain = [...specializes];
       const children = this.getChildSymbols(symbol, symbolTable);
       const features = children.filter((c) => isUsage(c.kind)).map((c) => {
-        const modifier = this.extractModifier(c, lines);
-        const direction = this.extractDirection(c, lines);
+        const prefix = prefixAttributesOf(c);
         return {
           name: c.name,
           kind: toMetaclassName(c.kind),
           type: c.typeNames.join(", ") || void 0,
           multiplicity: c.multiplicity,
-          direction,
+          direction: prefix.direction,
           visibility: c.visibility,
-          isDerived: modifier?.split(", ").includes("derived") ?? false,
-          isReadonly: modifier?.split(", ").includes("readonly") ?? false
+          isDerived: prefix.keywords.includes("derived"),
+          isConstant: prefix.isConstant,
+          isReadonly: prefix.isConstant
         };
       });
       result[qualifiedName] = {
@@ -127508,67 +127701,6 @@ var SysMLModelProvider = class {
     const endLine = Math.min(symbol.range.end.line, lines.length - 1);
     return lines.slice(startLine, endLine + 1).join("\n");
   }
-  /** Extract port direction (in | out | inout) from source text. */
-  extractDirection(symbol, lines) {
-    if (symbol.kind !== "port" /* PortUsage */ && symbol.kind !== "port def" /* PortDef */) {
-      return void 0;
-    }
-    const elementText = this.getElementText(symbol, lines);
-    if (containsWord(elementText, "inout")) return "inout";
-    if (containsWord(elementText, "in")) return "in";
-    if (containsWord(elementText, "out")) return "out";
-    return void 0;
-  }
-  /** Extract modifiers (abstract, readonly, derived, etc.) from source text. */
-  extractModifier(symbol, lines) {
-    const elementText = this.getElementText(symbol, lines);
-    const modifiers = [];
-    if (containsWord(elementText, "abstract")) modifiers.push("abstract");
-    if (containsWord(elementText, "readonly")) modifiers.push("readonly");
-    if (containsWord(elementText, "derived")) modifiers.push("derived");
-    if (containsWord(elementText, "variation")) modifiers.push("variation");
-    if (containsWord(elementText, "individual")) modifiers.push("individual");
-    return modifiers.length > 0 ? modifiers.join(", ") : void 0;
-  }
-  /** Extract default/assigned value from source text. */
-  extractValue(symbol, lines) {
-    if (symbol.kind !== "attribute" /* AttributeUsage */) {
-      return void 0;
-    }
-    const elementText = this.getElementText(symbol, lines);
-    const eqIdx = elementText.indexOf("=");
-    if (eqIdx < 0) return void 0;
-    let start = eqIdx + 1;
-    if (start < elementText.length && elementText[start] === "=") return void 0;
-    start = skipWS(elementText, start);
-    let end = start;
-    while (end < elementText.length) {
-      const ch = elementText[end];
-      if (ch === ";" || ch === "{" || ch === "}" || ch === "\n") break;
-      end++;
-    }
-    const val = elementText.substring(start, end).trim();
-    if (val && !val.includes("def") && val.length < 100) {
-      return val;
-    }
-    return void 0;
-  }
-  /** Extract all specialization targets from `:>` or `specializes` syntax. */
-  extractSpecializations(symbol, lines) {
-    const elementText = this.getElementText(symbol, lines);
-    const colonGtIdx = elementText.indexOf(":>");
-    if (colonGtIdx >= 0) {
-      if (colonGtIdx + 2 < elementText.length && elementText[colonGtIdx + 2] === ">") {
-      } else {
-        return readCommaSeparatedIdents(elementText, colonGtIdx + 2);
-      }
-    }
-    const specPositions = findWordPositions(elementText, "specializes");
-    if (specPositions.length > 0) {
-      return readCommaSeparatedIdents(elementText, specPositions[0].afterPos);
-    }
-    return [];
-  }
   /** Extract connection endpoints from `connect` syntax. */
   extractConnectionEndpoints(symbol, lines) {
     const elementText = this.getElementText(symbol, lines);
@@ -127632,16 +127764,6 @@ var SysMLModelProvider = class {
     const fromElement = { source: elementName, sourceId: element.symbolId };
     elementText = stripComments(elementText);
     const rels = [];
-    const subsetsPositions = findWordPositions(elementText, "subsets");
-    if (subsetsPositions.length > 0) {
-      const [target] = readWordAfterKeyword(elementText, subsetsPositions[0].afterPos);
-      if (target) rels.push({ type: "subsetting", ...fromElement, target });
-    }
-    const redefPositions = findWordPositions(elementText, "redefines");
-    if (redefPositions.length > 0) {
-      const [target] = readWordAfterKeyword(elementText, redefPositions[0].afterPos);
-      if (target) rels.push({ type: "redefinition", ...fromElement, target });
-    }
     const satisfyPositions = findWordPositions(elementText, "satisfy");
     if (satisfyPositions.length > 0) {
       let pos = skipWS(elementText, satisfyPositions[0].afterPos);
@@ -127935,6 +128057,21 @@ ${this.followingBranchStatements(symbol, lines)}`;
     };
   }
 };
+var DIRECTIONS = /* @__PURE__ */ new Set(["in", "out", "inout"]);
+var MULTIPLICITY_KEYWORDS = /* @__PURE__ */ new Set(["ordered", "nonunique"]);
+function prefixAttributesOf(symbol) {
+  const keywords = symbol.prefixKeywords ?? [];
+  const direction = keywords.find((keyword) => DIRECTIONS.has(keyword));
+  const modifiers = keywords.filter((keyword) => !DIRECTIONS.has(keyword) && !MULTIPLICITY_KEYWORDS.has(keyword));
+  return {
+    keywords,
+    direction,
+    modifier: modifiers.length > 0 ? modifiers.join(", ") : void 0,
+    isConstant: keywords.includes("constant"),
+    ordered: keywords.includes("ordered"),
+    nonunique: keywords.includes("nonunique")
+  };
+}
 
 // server/src/platform/connection.ts
 var import_node = __toESM(require_node3());
@@ -128608,7 +128745,7 @@ var SYSML_KEYWORDS2 = [
   { label: "satisfy", kind: import_node3.CompletionItemKind.Operator, detail: "Satisfaction", documentation: "Indicates requirement satisfaction", insertText: "satisfy ${1:requirement} by ${2:element};", insertTextFormat: import_node3.InsertTextFormat.Snippet },
   // Modifiers
   { label: "abstract", kind: import_node3.CompletionItemKind.Keyword, detail: "Abstract modifier", documentation: "Makes element abstract" },
-  { label: "readonly", kind: import_node3.CompletionItemKind.Keyword, detail: "Readonly modifier", documentation: "Makes attribute readonly" },
+  { label: "constant", kind: import_node3.CompletionItemKind.Keyword, detail: "Constant modifier", documentation: "Makes feature constant" },
   { label: "derived", kind: import_node3.CompletionItemKind.Keyword, detail: "Derived modifier", documentation: "Indicates value is derived/calculated" },
   { label: "in", kind: import_node3.CompletionItemKind.Keyword, detail: "Input direction", documentation: "Port/parameter receives input" },
   { label: "out", kind: import_node3.CompletionItemKind.Keyword, detail: "Output direction", documentation: "Port/parameter provides output" },

package/package.json

@@ -2,7 +2,7 @@
   "name": "sysml-v2-lsp",
   "displayName": "SysML v2 Language Server",
   "description": "Language Server Protocol implementation for SysML v2, powered by ANTLR4",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "publisher": "JamieD",
   "license": "MIT",
   "repository": {