sysml-validate 0.14.5 → 0.15.1

package/out/main.js

@@ -30760,6 +30760,9 @@ function isExhibitStateDecl(item) {
 var ExitAction = "ExitAction";
 var ExposeMember = "ExposeMember";
 var ExposePath = "ExposePath";
+function isExposePath(item) {
+  return reflection2.isInstance(item, ExposePath);
+}
 var ExpressionDecl = "ExpressionDecl";
 var FeatureDecl = "FeatureDecl";
 function isFeatureDecl(item) {
@@ -58052,14 +58055,14 @@ function evaluateFilterCondition(node, metadataTypes, resolveRefs) {
     return node.items.length === 1 ? evaluateFilterCondition(node.items[0], metadataTypes, resolveRefs) : void 0;
   }
   if (isBinExpr(node)) {
-    if (node.op === "and" || node.op === "&") {
+    if (CONJUNCTION_OPERATORS.has(node.op)) {
       const left = evaluateFilterCondition(node.left, metadataTypes, resolveRefs);
       const right = evaluateFilterCondition(node.right, metadataTypes, resolveRefs);
       if (left === false || right === false)
         return false;
       return left === void 0 || right === void 0 ? void 0 : true;
     }
-    if (node.op === "or" || node.op === "|") {
+    if (DISJUNCTION_OPERATORS.has(node.op)) {
       const left = evaluateFilterCondition(node.left, metadataTypes, resolveRefs);
       const right = evaluateFilterCondition(node.right, metadataTypes, resolveRefs);
       if (left === true || right === true)
@@ -58070,6 +58073,42 @@ function evaluateFilterCondition(node, metadataTypes, resolveRefs) {
   }
   return void 0;
 }
+var CONJUNCTION_OPERATORS = /* @__PURE__ */ new Set(["and", "&"]);
+var DISJUNCTION_OPERATORS = /* @__PURE__ */ new Set(["or", "|"]);
+function undecidableFilterCondition(condition) {
+  if (!condition)
+    return void 0;
+  if (isSelfClassifyExpr(condition)) {
+    return condition.op === "@" || condition.op === "@@" ? void 0 : { node: condition, construct: `the '${condition.op}' classification operator` };
+  }
+  if (isNotExpr(condition) && condition.operand) {
+    return undecidableFilterCondition(condition.operand);
+  }
+  if (condition.$type === "NotExpr")
+    return void 0;
+  if (isParenExpr(condition)) {
+    return condition.items.length === 1 ? undecidableFilterCondition(condition.items[0]) : { node: condition, construct: "a parenthesized expression list" };
+  }
+  if (isBinExpr(condition)) {
+    if (CONJUNCTION_OPERATORS.has(condition.op) || DISJUNCTION_OPERATORS.has(condition.op)) {
+      return undecidableFilterCondition(condition.left) ?? undecidableFilterCondition(condition.right);
+    }
+    return { node: condition, construct: `the '${condition.op}' operator` };
+  }
+  return { node: condition, construct: describeFilterExpr(condition) };
+}
+function describeFilterExpr(node) {
+  if (isPostfixOp(node)) {
+    if ((node.dot || node.select) && node.field)
+      return `the '.${node.field}' feature access`;
+    if (node.arrow && node.invoke)
+      return `the '->${node.invoke}' invocation`;
+    return "this postfix expression";
+  }
+  if (isPathExpr(node))
+    return "a plain feature reference";
+  return "this expression form";
+}
 function attachedMetadataTypes(node, resolveRefs) {
   const siblings = node.$container?.members;
   if (!Array.isArray(siblings))
@@ -58713,6 +58752,13 @@ var DIAGNOSTIC_MESSAGES = {
   // implicit-redefinition resolution this validator does not yet model.
   RES017_DUPLICATE_MEMBER: (name) => `'${name}' is already declared in this namespace. Members must be distinguishable by name \u2014 rename or remove the duplicate.`,
   RES017_DUPLICATE_SHORT_NAME: (name) => `Short name '<${name}>' is already used in this namespace. Members must be distinguishable \u2014 rename the short name.`,
+  // issue #102 — REQ-387. The filter evaluator (`import-visibility.ts`,
+  // `evaluateFilterCondition`) decides metadata-presence tests and the Boolean
+  // operators over them; every other form fails OPEN, keeping the member. Failing
+  // open is the right default — under-importing would manufacture spurious
+  // RES001s — but an unevaluated filter produces a scope or view that looks
+  // authoritative and is not, so the fail-open is stated rather than assumed.
+  RES018_UNEVALUATED_FILTER: (subject, construct) => `${subject} filter is not evaluated: ${construct} is outside the metadata-filter evaluator, which decides '@'/'@@' metadata tests combined with 'not', 'and'/'&', and 'or'/'|'. The filter fails open \u2014 it is treated as pass-through and removes nothing.`,
   // REQ-007 — SysML v1 → v2 migration guardrail.
   MIG001_V1_KEYWORD: (keyword, v2, note) => `'${keyword}' is a SysML v1 construct, not a SysML v2 keyword. ${note} Use '${v2}'.`,
   MIG002_V1_STEREOTYPE_KNOWN: (stereotype, v2, note) => `SysML v2 has no stereotypes. ${note} Replace \xAB${stereotype}\xBB with '${v2}'.`,
@@ -59496,6 +59542,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 +59785,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);
@@ -60546,6 +60613,7 @@ ${baseIndent}}`;
   checkCrossReferences(node, accept) {
     const index = this.buildIndex();
     const imports = [];
+    const exposePaths = [];
     const decls = [];
     const verifyStmts = [];
     const satisfyStmts = [];
@@ -60557,7 +60625,9 @@ ${baseIndent}}`;
         const path10 = importedPath(child);
         if (alias && path10 && importWildcard(child) === "none")
           aliasMap.set(alias, path10);
-      } else if (isVerifyStmt(child))
+      } else if (isExposePath(child))
+        exposePaths.push(child);
+      else if (isVerifyStmt(child))
         verifyStmts.push(child);
       else if (isSatisfyStmt(child))
         satisfyStmts.push(child);
@@ -60573,6 +60643,7 @@ ${baseIndent}}`;
     this.checkPrivateImports(imports, index, accept);
     this.checkPrivateWildcardReferences(node, imports, index, accept);
     this.checkImportCycles(imports, index, accept);
+    this.checkUnevaluatedFilters(imports, exposePaths, accept);
     if (sysmlDiagnosticSettings.unusedImports !== "off") {
       this.checkUnusedImports(node, imports, index, sysmlDiagnosticSettings.unusedImports, accept);
     }
@@ -60602,6 +60673,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
@@ -61148,6 +61262,34 @@ ${baseIndent}}`;
     }
     return false;
   }
+  /**
+   * REQ-387 — RES018: an `import` or `expose` filter the metadata-filter
+   * evaluator cannot decide (issue #102).
+   *
+   * The evaluator keeps a member it cannot decide, so an unevaluated filter
+   * silently contributes the members it was written to exclude — a scope or a
+   * view that reads as authoritative and is not. Failing open stays (narrowing
+   * on a guess would manufacture unresolved-name errors); what changes is that
+   * the model now says so at the filter that is not applied.
+   *
+   * Default severity is `info` rather than a warning: the model is legal and the
+   * limitation is this evaluator's, not the author's. Teams that want an
+   * unevaluated filter to break a build raise it per code through
+   * `sysml.validation.severities` (REQ-240).
+   */
+  checkUnevaluatedFilters(imports, exposePaths, accept) {
+    const report = (condition, subject) => {
+      const undecidable = undecidableFilterCondition(condition);
+      if (!undecidable)
+        return;
+      accept(severity("RES018", "info"), DIAGNOSTIC_MESSAGES.RES018_UNEVALUATED_FILTER(subject, undecidable.construct), { node: undecidable.node, code: "RES018" });
+    };
+    for (const imp of imports)
+      for (const filter3 of imp.filters)
+        report(filter3.condition, "Import");
+    for (const path10 of exposePaths)
+      report(path10.condition, "Expose");
+  }
   // REQ-324 — RES009 unused import (configurable, OFF by default)
   checkUnusedImports(root3, imports, index, level, accept) {
     if (imports.length === 0)
@@ -68967,7 +69109,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.14.5" : "dev";
+var VERSION2 = true ? "0.15.1" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {