sysml-validate 0.14.5 → 0.15.0

package/out/main.js

@@ -59496,6 +59496,26 @@ 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;
@@ -59719,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);
@@ -60602,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
@@ -68967,7 +69031,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.14.5" : "dev";
+var VERSION2 = true ? "0.15.0" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {