sysml-validate 0.14.4 → 0.15.0

package/out/main.js

@@ -58699,6 +58699,11 @@ 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.",
+  // 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
+  // message names the construct it means rather than "action language".
+  SEM011_ACTION_ONLY_CONSTRUCT: (construct, clause, owner) => `${construct} may only be declared in the body of an action definition or usage (OMG SysML v2 Part 1 \xA7${clause}), not in ${owner}.`,
   RES016_LIBRARY_SHADOWING: (name) => `'${name}' shadows a standard-library element of the same name; the library symbol is hidden in this scope.`,
   // issue #183 — KerML namespace distinguishability (validateNamespaceDistinguishability).
   // Owned siblings sharing a name/short name (or an alias clashing with an owned
@@ -59449,6 +59454,68 @@ var CONSTRAINT_SIDE_EFFECT_TYPES = /* @__PURE__ */ new Set([
   "DoAction",
   "ExitAction"
 ]);
+var ACTION_BODY_TYPES = /* @__PURE__ */ new Set([
+  "ActionDecl",
+  "PerformStmt",
+  "MergeNode",
+  "DecideNode",
+  "JoinNode",
+  "ForkNode",
+  "IfActionNode",
+  "WhileLoopNode",
+  "LoopNode",
+  "ForLoopNode",
+  "SendNode",
+  "AcceptNode",
+  "AssignNode",
+  "TerminateNode",
+  "StateDecl",
+  "ExhibitStateDecl",
+  "TransitionDecl",
+  "EntryAction",
+  "DoAction",
+  "ExitAction",
+  "CalcDecl",
+  "CaseDecl",
+  "UseCaseDecl",
+  "AnalysisCaseDecl",
+  "VerificationCaseDecl"
+]);
+var CONTROL_NODE_KEYWORDS = {
+  MergeNode: "merge",
+  DecideNode: "decide",
+  JoinNode: "join",
+  ForkNode: "fork"
+};
+var SUCCESSION_MEMBER_WRAPPERS = /* @__PURE__ */ new Set([
+  "ThenActionMember",
+  "ElseSuccessionMember",
+  "PrefixMetadataMember"
+]);
+function actionOnlyConstruct(node) {
+  const keyword = CONTROL_NODE_KEYWORDS[node.$type];
+  return keyword ? { construct: `A '${keyword}' control node`, clause: "7.17.3" } : void 0;
+}
+function portionKindOf(node) {
+  const mods = node.modifiers;
+  if (!Array.isArray(mods))
+    return void 0;
+  return mods.find((m) => m === "timeslice" || m === "snapshot");
+}
+var NAMESPACE_ONLY_TYPES = /* @__PURE__ */ new Set(["Package", "Document", "NamespaceDecl"]);
+function owningTypeOf(node) {
+  let owner = node.$container;
+  while (owner && (owner.$type === "PrefixMetadataMember" || owner.$type === "ThenActionMember")) {
+    owner = owner.$container;
+  }
+  if (!owner)
+    return void 0;
+  return NAMESPACE_ONLY_TYPES.has(owner.$type) ? void 0 : owner;
+}
+function declLabel(node, kind) {
+  const name = node.name;
+  return name ? `'${name}'` : `this '${kind}'`;
+}
 var SysmlValidator = class _SysmlValidator {
   indexManager;
   langiumDocuments;
@@ -59538,6 +59605,26 @@ var SysmlValidator = class _SysmlValidator {
       }
     }
   }
+  // REQ-385 — SEM011. A fork/join/decide/merge control node "can only be declared
+  // in the body of an action definition or usage" (OMG SysML v2 Part 1 §7.17.3).
+  // Written in a part, one parsed and drew silently, which is how a part came to
+  // show control flow it cannot own (user report 2026-08-09). See
+  // `actionOnlyConstruct` for the constructs deliberately NOT covered.
+  checkActionFlowPlacement(node, accept) {
+    const restricted = actionOnlyConstruct(node);
+    if (!restricted)
+      return;
+    if (SUCCESSION_MEMBER_WRAPPERS.has(node.$container?.$type ?? ""))
+      return;
+    let owner = node.$container;
+    while (owner && SUCCESSION_MEMBER_WRAPPERS.has(owner.$type))
+      owner = owner.$container;
+    if (!owner || ACTION_BODY_TYPES.has(owner.$type))
+      return;
+    const ownerName = owner.name;
+    const ownerKind = DECL_KEYWORDS[owner.$type] ?? "this context";
+    accept(severity("SEM011", "warning"), DIAGNOSTIC_MESSAGES.SEM011_ACTION_ONLY_CONSTRUCT(restricted.construct, restricted.clause, ownerName ? `${ownerKind} '${ownerName}'` : ownerKind), { node, code: "SEM011" });
+  }
   // REQ-148, REQ-294, REQ-315, REQ-330 — SEM006/SYN092 requirement definition must have a subject
   checkRequirementDecl(node, accept) {
     if (!node.isDef || !node.name)
@@ -59652,6 +59739,7 @@ var SysmlValidator = class _SysmlValidator {
     this.checkLanguageDisjointness(node, accept);
     this.checkKermlWellFormedness(node, accept);
     this.checkFilterExpressions(node, accept);
+    this.checkOccurrencePortions(node, accept);
     this.checkCrossReferences(node, accept);
     this.checkAutoImportSuggestions(node, accept);
     this.checkUnits(node, accept);
@@ -60535,6 +60623,49 @@ ${baseIndent}}`;
       this.checkTypeComposition(decl, index, accept);
     }
   }
+  // ══════════════════════════════════════════════════════════════════════
+  // REQ-160 — occurrence portions: `timeslice` / `snapshot` well-formedness
+  // ══════════════════════════════════════════════════════════════════════
+  // The declaration kinds that are NOT occurrences, so a portion of their life is
+  // meaningless. Kept as a deny-list rather than an allow-list because nearly every
+  // SysML usage kind IS an OccurrenceUsage (part, item, action, state, port,
+  // connection, case, …) while the data-valued ones are few and closed: an
+  // AttributeUsage is typed by a DataType and an enumeration is a special attribute,
+  // neither of which has a life to carve up.
+  static NON_OCCURRENCE_OWNER_TYPES = /* @__PURE__ */ new Set(["AttributeDecl", "EnumDecl", "EnumValueDecl", "MetadataDecl", "MultiplicityDecl"]);
+  // REQ-160 — OMG SysML v2 §8.2.2.9 (Occurrences) with the Kernel Semantic Library
+  // `Occurrences::TimeSlice` / `Occurrences::Snapshot`:
+  //
+  //  SSM015 — a portion is a portion OF something. Its owning type must be an
+  //           occurrence; declared at package level (or inside an attribute /
+  //           enumeration body) there is no life for it to be a portion of.
+  //  SSM016 — `Snapshot :> TimeSlice` with a zero duration: a snapshot is the
+  //           occurrence at ONE instant. Every portion of a zero-duration
+  //           occurrence is itself zero-duration, so a snapshot may own further
+  //           snapshots but never a `timeslice`.
+  //
+  // Both are structural — they read modifiers and owners only — so they hold
+  // without resolving a single cross-reference.
+  checkOccurrencePortions(node, accept) {
+    for (const child of ast_utils_exports.streamAllContents(node)) {
+      const kind = portionKindOf(child);
+      if (!kind)
+        continue;
+      const label = declLabel(child, kind);
+      const owner = owningTypeOf(child);
+      if (!owner) {
+        accept(severity("SSM015", "error"), `A '${kind}' is a portion of an occurrence's life, so ${label} must be declared inside an occurrence \u2014 not directly in a package.`, { node: child, code: "SSM015" });
+        continue;
+      }
+      if (_SysmlValidator.NON_OCCURRENCE_OWNER_TYPES.has(owner.$type)) {
+        accept(severity("SSM015", "error"), `A '${kind}' is a portion of an occurrence's life, and '${owner.name ?? owner.$type}' is not an occurrence.`, { node: child, code: "SSM015" });
+        continue;
+      }
+      if (kind === "timeslice" && portionKindOf(owner) === "snapshot") {
+        accept(severity("SSM016", "error"), `A 'snapshot' is a zero-duration timeslice, so ${label} cannot be a timeslice of it \u2014 a portion of an instant is itself a snapshot.`, { node: child, code: "SSM016" });
+      }
+    }
+  }
   // REQ-328 — KSM008: a `filter` membership condition must be Boolean. Only a
   // *definitely* non-Boolean expression is flagged — a string or numeric/quantity
   // literal, or an arithmetic/range binary expression. A bare feature path is left
@@ -61267,7 +61398,12 @@ ${baseIndent}}`;
       StateDecl: this.checkStateDecl.bind(this),
       Import: this.checkImport.bind(this),
       Package: this.checkPackage.bind(this),
-      VerifyStmt: this.checkVerifyStmt.bind(this)
+      VerifyStmt: this.checkVerifyStmt.bind(this),
+      // REQ-385 — SEM011: the action language OMG confines to an action body.
+      MergeNode: this.checkActionFlowPlacement.bind(this),
+      DecideNode: this.checkActionFlowPlacement.bind(this),
+      JoinNode: this.checkActionFlowPlacement.bind(this),
+      ForkNode: this.checkActionFlowPlacement.bind(this)
     };
   }
 };
@@ -68895,7 +69031,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.14.4" : "dev";
+var VERSION2 = true ? "0.15.0" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {