sysml-validate 0.15.0 → 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}'.`,
@@ -60567,6 +60613,7 @@ ${baseIndent}}`;
   checkCrossReferences(node, accept) {
     const index = this.buildIndex();
     const imports = [];
+    const exposePaths = [];
     const decls = [];
     const verifyStmts = [];
     const satisfyStmts = [];
@@ -60578,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);
@@ -60594,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);
     }
@@ -61212,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)
@@ -69031,7 +69109,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.15.0" : "dev";
+var VERSION2 = true ? "0.15.1" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {