sysml-diagram 0.33.0 → 0.34.0

package/out/main.js

@@ -175867,6 +175867,73 @@ function implicitSpecializationsFor(shared) {
   return created;
 }
 
+// ../language-server/out/src/services/modifier-order.js
+var MODIFIER_RANK = /* @__PURE__ */ new Map([
+  ["public", 0],
+  ["private", 0],
+  ["protected", 0],
+  ["in", 1],
+  ["out", 1],
+  ["inout", 1],
+  ["derived", 2],
+  ["abstract", 3],
+  ["variation", 4],
+  ["variant", 4],
+  ["composite", 5],
+  ["constant", 6],
+  ["const", 6],
+  ["ref", 7],
+  ["var", 8],
+  ["individual", 9],
+  ["snapshot", 10],
+  ["timeslice", 10]
+]);
+var CANONICAL_MODIFIER_ORDER = "visibility, direction, derived, abstract, variation, composite, constant, ref, var, individual, then the portion kind";
+function isRankedRun(modifiers2) {
+  return modifiers2.every((m) => MODIFIER_RANK.has(m));
+}
+function firstMisplacedModifier(modifiers2) {
+  if (modifiers2.length < 2 || !isRankedRun(modifiers2))
+    return void 0;
+  for (let index2 = 1; index2 < modifiers2.length; index2++) {
+    const rank = MODIFIER_RANK.get(modifiers2[index2]);
+    for (let before = 0; before < index2; before++) {
+      if (MODIFIER_RANK.get(modifiers2[before]) > rank)
+        return { index: index2, before };
+    }
+  }
+  return void 0;
+}
+var MODIFIER_PROPERTIES = ["modifiers", "postModifiers"];
+function modifierRunsOf(node) {
+  const runs = [];
+  if (!node.$cstNode)
+    return runs;
+  for (const property3 of MODIFIER_PROPERTIES) {
+    const modifiers2 = node[property3];
+    if (!Array.isArray(modifiers2) || modifiers2.length < 2)
+      continue;
+    if (!modifiers2.every((m) => typeof m === "string"))
+      continue;
+    if (!isRankedRun(modifiers2))
+      continue;
+    const nodes = grammar_utils_exports.findNodesForProperty(node.$cstNode, property3);
+    if (nodes.length !== modifiers2.length)
+      continue;
+    if (nodes.some((cst, index2) => cst.text !== modifiers2[index2]))
+      continue;
+    runs.push({ property: property3, modifiers: modifiers2, nodes });
+  }
+  return runs;
+}
+function isRewritableRun(source, run) {
+  const written = source.slice(run.nodes[0].offset, run.nodes[run.nodes.length - 1].end);
+  return new RegExp(`^${run.modifiers.join("[ \\t]+")}$`, "u").test(written);
+}
+function canonicalModifierOrder(modifiers2) {
+  return modifiers2.map((modifier, index2) => ({ modifier, index: index2, rank: MODIFIER_RANK.get(modifier) ?? 0 })).sort((a2, b) => a2.rank - b.rank || a2.index - b.index).map((entry) => entry.modifier);
+}
+
 // ../language-server/out/src/messages.js
 var DIAGNOSTIC_MESSAGES = {
   // REQ-006 - a broad diagram anchor cannot prove which typed occurrence owns
@@ -175880,6 +175947,10 @@ var DIAGNOSTIC_MESSAGES = {
   LEX004_INVALID_STRING_ESCAPE: (escape) => `Invalid escape '\\${escape}'. KerML Table 4 permits \\' \\" \\b \\f \\t \\n and \\\\.`,
   LEX008_NON_ASCII_IDENTIFIER: (name) => `Identifier '${name}' contains a non-ASCII character. Wrap it in single quotes ('${name}') to use it as an unrestricted name.`,
   LEX009_TRAILING_WHITESPACE: "Trailing whitespace.",
+  // issue #163: SYN025. The grammar accepts any permutation of the leading
+  // modifiers so a mis-ordered declaration still parses; this names the one word
+  // that is out of place and shows the whole prefix as the BNF writes it.
+  SYN025_MODIFIER_ORDER: (modifier, before, canonical) => `Modifier '${modifier}' must be written before '${before}'. The canonical declaration prefix order is ${CANONICAL_MODIFIER_ORDER}; write '${canonical}'.`,
   // REQ-385 — OMG SysML v2 Part 1 §7.17.3 restricts control nodes to the body of
   // an action definition or usage. Successions are NOT covered (§7.13.5 sanctions
   // `first a then b;` and the `then` occurrence shorthand in a part), so the
@@ -180142,6 +180213,7 @@ var SysmlValidator = class _SysmlValidator {
     this.checkActionFlowStyle(node, accept);
     this.checkKeywordOrdering(node, accept);
     this.checkModifierPlacement(node, accept);
+    this.checkModifierOrder(node, accept);
     this.checkEnumerations(node, accept);
     this.checkVariability(node, accept);
     this.checkMultiplicities(node, accept);
@@ -180950,6 +181022,46 @@ ${baseIndent}}`;
       }
     }
   }
+  // REQ-413 — SYN025 canonical order of the leading declaration modifiers.
+  //
+  // `DeclarationPrefix` accepts any permutation so that a mis-ordered prefix
+  // still parses; this is the rule that then says the order is wrong, and the
+  // only place that knows it is `modifier-order.ts`, shared with the quick fix
+  // and the formatter.
+  //
+  // Read off the parsed AST rather than the text, so a modifier word inside a
+  // comment, a string, a documentation body or a name can never reach it. A run
+  // holding a modifier with no canonical position is skipped whole
+  // (`UNRANKED_MODIFIERS`). One diagnostic per RUN, not per declaration: an end
+  // writes two prefixes (`end ref constant a;`), each with its own fix, but the
+  // fix rewrites a whole run, so a second squiggle within one run would name work
+  // the first has already done.
+  checkModifierOrder(node, accept) {
+    const source = ast_utils_exports.getDocument(node)?.textDocument.getText();
+    for (const child of ast_utils_exports.streamAllContents(node)) {
+      for (const run of modifierRunsOf(child)) {
+        const misplaced = firstMisplacedModifier(run.modifiers);
+        if (!misplaced)
+          continue;
+        const canonical = canonicalModifierOrder(run.modifiers).join(" ");
+        const first2 = run.nodes[0];
+        const last2 = run.nodes[run.nodes.length - 1];
+        accept(severity("SYN025", "warning"), DIAGNOSTIC_MESSAGES.SYN025_MODIFIER_ORDER(run.modifiers[misplaced.index], run.modifiers[misplaced.before], canonical), {
+          node: child,
+          range: run.nodes[misplaced.index].range,
+          code: "SYN025",
+          // The fix rewrites the whole run, so offer it only where a
+          // one-line replacement loses nothing.
+          ...source !== void 0 && isRewritableRun(source, run) ? {
+            data: {
+              replacement: canonical,
+              range: { start: first2.range.start, end: last2.range.end }
+            }
+          } : {}
+        });
+      }
+    }
+  }
   // REQ-409 - Enumeration definitions and usages specialize the general
   // variation, attribute and reference rules with a closed value inventory.
   checkEnumerations(node, accept) {
@@ -184393,6 +184505,16 @@ function isAliasFixData(data) {
 function isReplacementFixData(data) {
   return typeof data === "object" && data !== null && typeof data.replacement === "string";
 }
+function isReorderFixData(data) {
+  if (typeof data !== "object" || data === null)
+    return false;
+  const { replacement, range } = data;
+  if (typeof replacement !== "string" || typeof range !== "object" || range === null)
+    return false;
+  const { start: start2, end } = range;
+  const isPosition = (p) => typeof p === "object" && p !== null && typeof p.line === "number" && typeof p.character === "number";
+  return isPosition(start2) && isPosition(end);
+}
 function leafAtOffset2(node, offset2) {
   if (isLeafCstNode(node)) {
     return node.offset <= offset2 && offset2 < node.offset + node.length ? node : void 0;
@@ -184563,6 +184685,18 @@ var SysmlCodeActionProvider = class {
           });
         }
       }
+      if (code === "SYN025" && isReorderFixData(diagnostic.data)) {
+        actions.push({
+          title: `Reorder modifiers to '${diagnostic.data.replacement}'`,
+          kind: import_vscode_languageserver18.CodeActionKind.QuickFix,
+          diagnostics: [diagnostic],
+          edit: {
+            changes: {
+              [uri]: [import_vscode_languageserver18.TextEdit.replace(diagnostic.data.range, diagnostic.data.replacement)]
+            }
+          }
+        });
+      }
       if (code === "RES021") {
         actions.push({
           title: "Make this root import 'private'",
@@ -185291,6 +185425,25 @@ ${line2.indent}${unit}`
     });
   }
 }
+function modifierOrderRewrites(document2, out) {
+  const root4 = document2.parseResult?.value;
+  if (!root4)
+    return;
+  const source = document2.textDocument.getText();
+  for (const node of ast_utils_exports.streamAllContents(root4)) {
+    for (const run of modifierRunsOf(node)) {
+      if (!firstMisplacedModifier(run.modifiers))
+        continue;
+      if (!isRewritableRun(source, run))
+        continue;
+      out.push({
+        offset: run.nodes[0].offset,
+        end: run.nodes[run.nodes.length - 1].end,
+        newText: canonicalModifierOrder(run.modifiers).join(" ")
+      });
+    }
+  }
+}
 function withinRange(document2, rewrite, range) {
   if (!range)
     return true;
@@ -185300,25 +185453,26 @@ function withinRange(document2, rewrite, range) {
 function styleEdits(input) {
   const { document: document2, settings, options, baseEdits, protectedRanges, range, reservedKeywords } = input;
   const wantsRewrite = settings.emptyBody !== "preserve" || settings.quotedNames !== "preserve" || settings.documentationIndent !== "preserve" || settings.keywords !== "preserve" || settings.lineWidth > 0;
-  if (!wantsRewrite)
-    return [];
   const leaves = leavesOf(document2);
   if (leaves.length === 0)
     return [];
-  const projection2 = projectFormatted(document2, baseEdits);
   const rewrites = [];
-  if (settings.keywords === "symbolic")
-    keywordRewrites(leaves, rewrites);
-  if (settings.emptyBody !== "preserve") {
-    emptyBodyRewrites(document2, leaves, projection2, settings, options, rewrites);
-  }
-  if (settings.quotedNames === "unquoteSafe")
-    quotedNameRewrites(leaves, reservedKeywords, rewrites);
-  if (settings.documentationIndent === "align") {
-    documentationRewrites(document2, leaves, projection2, options, rewrites);
-  }
-  if (settings.lineWidth > 0)
-    wrapRewrites(leaves, projection2, options, settings.lineWidth, rewrites);
+  modifierOrderRewrites(document2, rewrites);
+  if (wantsRewrite) {
+    const projection2 = projectFormatted(document2, baseEdits);
+    if (settings.keywords === "symbolic")
+      keywordRewrites(leaves, rewrites);
+    if (settings.emptyBody !== "preserve") {
+      emptyBodyRewrites(document2, leaves, projection2, settings, options, rewrites);
+    }
+    if (settings.quotedNames === "unquoteSafe")
+      quotedNameRewrites(leaves, reservedKeywords, rewrites);
+    if (settings.documentationIndent === "align") {
+      documentationRewrites(document2, leaves, projection2, options, rewrites);
+    }
+    if (settings.lineWidth > 0)
+      wrapRewrites(leaves, projection2, options, settings.lineWidth, rewrites);
+  }
   const doc = document2.textDocument;
   const source = doc.getText();
   const accepted = [];
@@ -185343,8 +185497,8 @@ function styleEdits(input) {
 
 // ../language-server/out/src/services/formatter.js
 var INDENT = Formatting.indent({ allowMore: true });
-var DEDENT = Formatting.noIndent();
 var NL = Formatting.newLine();
+var DEDENT_NL = { options: {}, moves: [{ lines: 1, tabs: -1 }] };
 var SPACE = Formatting.oneSpace();
 var NO_SPACE = Formatting.noSpace();
 var SysmlFormatter = class extends AbstractFormatter {
@@ -185470,14 +185624,15 @@ var SysmlFormatter = class extends AbstractFormatter {
    * leaves every other hidden-node path untouched.
    */
   createTextEdit(a2, b, formatting, context) {
-    const edits = super.createTextEdit(a2, b, formatting, context);
+    const action = formatting === DEDENT_NL && context.indentation <= 0 ? NL : formatting;
+    const edits = super.createTextEdit(a2, b, action, context);
     if (!b.hidden)
       return edits;
     const startRange = {
       start: { line: b.range.start.line, character: 0 },
       end: b.range.start
     };
-    context.indentation += this.findFittingMove(startRange, formatting.moves, context)?.tabs ?? 0;
+    context.indentation += this.findFittingMove(startRange, action.moves, context)?.tabs ?? 0;
     return edits;
   }
   // REQ-259 — Dispatch formatting from AST node kind
@@ -185606,10 +185761,10 @@ var SysmlFormatter = class extends AbstractFormatter {
   fmtBlock(node, keyword) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container)) {
-      f.keyword(keyword).prepend(Formatting.newLines(1 + this.active.blankLines));
+      this.lineAnchor(node, f, keyword).prepend(Formatting.newLines(1 + this.active.blankLines));
     }
     f.keyword(keyword).append(SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
   // REQ-355 — Filtered imports keep the `[@Meta]` condition tight against the path
   fmtImport(node) {
@@ -185625,11 +185780,26 @@ var SysmlFormatter = class extends AbstractFormatter {
       ff.keyword("@@").append(NO_SPACE);
     }
   }
+  /**
+   * REQ-258 — Where a member's line break belongs.
+   *
+   * A declaration's kind keyword is NOT always its first token: a leading
+   * modifier (`derived ref attribute a;`), a visibility (`private package P;`)
+   * or a `standard library` marker is written ahead of it. Prepending the
+   * newline to the keyword split such a declaration over two lines. Ask the CST
+   * where the node actually starts rather than listing the words that can come
+   * first, so a grammar change cannot quietly reintroduce the split.
+   */
+  lineAnchor(node, f, keyword) {
+    const start2 = node.$cstNode?.offset;
+    const at = grammar_utils_exports.findNodeForKeyword(node.$cstNode, keyword)?.offset;
+    return start2 !== void 0 && at !== void 0 && at > start2 ? f.node(node) : f.keyword(keyword);
+  }
   // REQ-258, REQ-260 — Format one element per line with canonical keyword spacing
   fmtElement(node, keyword) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container))
-      f.keyword(keyword).prepend(NL);
+      this.lineAnchor(node, f, keyword).prepend(NL);
     f.keyword(keyword).append(SPACE);
     if (node.isDef) {
       f.keyword("def").prepend(SPACE).append(SPACE);
@@ -185639,50 +185809,59 @@ var SysmlFormatter = class extends AbstractFormatter {
     f.keyword(":>>").surround(SPACE);
     f.keyword("=").surround(SPACE);
     f.keyword(";").prepend(NO_SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
   // REQ-260 — Keep multi-word `verification case` keyword phrase together
   fmtVerificationCase(node) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container))
-      f.keyword("verification").prepend(NL);
+      this.lineAnchor(node, f, "verification").prepend(NL);
     f.keyword("verification").append(SPACE);
     f.keyword("case").append(SPACE);
     if (node.isDef)
       f.keyword("def").append(SPACE);
     f.keyword(":").surround(SPACE);
     f.keyword(";").prepend(NO_SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
   // REQ-260 — Keep multi-word `analysis case` keyword phrase together
   fmtAnalysisCase(node) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container))
-      f.keyword("analysis").prepend(NL);
+      this.lineAnchor(node, f, "analysis").prepend(NL);
     f.keyword("analysis").append(SPACE);
     f.keyword("case").append(SPACE);
     if (node.isDef)
       f.keyword("def").append(SPACE);
     f.keyword(":").surround(SPACE);
     f.keyword(";").prepend(NO_SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
   // REQ-260 — Keep multi-word `use case` keyword phrase together
   fmtUseCase(node) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container))
-      f.keyword("use").prepend(NL);
+      this.lineAnchor(node, f, "use").prepend(NL);
     f.keyword("use").append(SPACE);
     f.keyword("case").append(SPACE);
     if (node.isDef)
       f.keyword("def").append(SPACE);
     f.keyword(":").surround(SPACE);
     f.keyword(";").prepend(NO_SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
-  fmtBraces(f) {
+  /**
+   * REQ-258 — A block's braces.
+   *
+   * The closing brace steps back out only when the body actually stepped in.
+   * An EMPTY body never opened a level (`{` and `}` are adjacent, and the
+   * indent `{` appends is spent on `}` itself), so dedenting it would take the
+   * brace one level below its owner.
+   */
+  fmtBraces(node, f) {
     f.keyword("{").surround(SPACE).append(INDENT);
-    f.keyword("}").prepend(DEDENT).prepend(NL);
+    const members = node.members;
+    f.keyword("}").prepend(members && members.length > 0 ? DEDENT_NL : NL);
   }
 };
 
@@ -210628,7 +210807,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.33.0" : "dev";
+var VERSION2 = true ? "0.34.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;