sysml-validate 0.15.2 → 0.15.3

package/out/main.js

@@ -45489,8 +45489,17 @@ var SysMLGrammar = () => loadedSysMLGrammar ?? (loadedSysMLGrammar = loadGrammar
                     "$type": "Group",
                     "elements": [
                       {
-                        "$type": "Keyword",
-                        "value": "."
+                        "$type": "Alternatives",
+                        "elements": [
+                          {
+                            "$type": "Keyword",
+                            "value": "."
+                          },
+                          {
+                            "$type": "Keyword",
+                            "value": "::"
+                          }
+                        ]
                       },
                       {
                         "$type": "Assignment",
@@ -58759,6 +58768,15 @@ var DIAGNOSTIC_MESSAGES = {
   // 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-389 — Namespace qualification versus feature chaining in every written path
+  // issue #213 — the KerML textual BNF binds `::` tighter than `.`: each
+  // dot-separated link of a FeatureChain is a complete QualifiedName, and only
+  // a Feature can be an `OwnedFeatureChaining::chainingFeature`. A Definition
+  // specializes Classifier, not Feature, so it can never sit on the LEFT of a
+  // dot. Our permissive scoping resolves the dotted form anyway (a definition
+  // is a Type, hence a Namespace), which is exactly why it needs saying: the
+  // Pilot implementation refuses the same text at linking time.
+  RES019_DEFINITION_IN_FEATURE_CHAIN: (segment, member) => `'${segment}' is a definition, not a usage, so '${member}' is reached through it with '::' rather than '.'. Only a feature can be chained with '.' (KerML FeatureChain).`,
   // 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}'.`,
@@ -59169,7 +59187,31 @@ var FeaturePathResolver = class {
   }
   // REQ-220/317 — resolve every independently clickable/diagnosable segment.
   resolve(node) {
-    const segments = this.segmentsOf(node);
+    return this.resolveSegments(node, this.segmentsOf(node));
+  }
+  // REQ-389 — Namespace qualification versus feature chaining in every written path
+  // issue #213 — a `perform` / `exhibit` target is stored as `name` plus an
+  // untyped `chainSegs` array, so `A::b`, `A.b` and `A.b::c` all collapse to the
+  // same AST and the separator rule is unenforceable from it. The CST still
+  // carries the separators verbatim; read the path back off it and resolve it
+  // exactly as an expression path is resolved.
+  resolveDeclarationPath(node) {
+    return this.resolveSegments(node, this.declarationSegmentsOf(node));
+  }
+  // REQ-389 — Namespace qualification versus feature chaining in every written path
+  // issue #213 — a connector end keeps its whole path in ONE datatype-string
+  // property (`ConnectorEnd.path`, a `RelationPath`), so there is no `chainSegs`
+  // list to read at all. Resolve it off that property's CST span instead; the
+  // separator rule is the same one, because a connector end reaches the world
+  // through the same OwnedReferenceSubsetting as `perform` and `exhibit`.
+  resolvePropertyPath(node, property3) {
+    const cst = node.$cstNode;
+    const propertyNode = cst ? grammar_utils_exports.findNodeForProperty(cst, property3) : void 0;
+    if (!cst || !propertyNode)
+      return { segments: [] };
+    return this.resolveSegments(node, this.segmentsInSpan(cst, propertyNode.offset, propertyNode.end));
+  }
+  resolveSegments(node, segments) {
     if (segments.length === 0)
       return { segments };
     const root3 = ast_utils_exports.getDocument(node).parseResult.value;
@@ -59218,6 +59260,61 @@ var FeaturePathResolver = class {
     }
     return segments;
   }
+  // REQ-389 — Namespace qualification versus feature chaining in every written path
+  // issue #213 — the path of a reference-form declaration (`perform A::b.c;`,
+  // `exhibit VehicleStates::operating;`) spans the `name` property through the
+  // last `chainSegs` element. Everything after it (a `redefines` tail, a typing,
+  // a body) belongs to other properties and must not be read as path segments,
+  // so the CST leaves are taken only from that span.
+  declarationSegmentsOf(node) {
+    const cst = node.$cstNode;
+    if (!cst)
+      return [];
+    const nameNode = grammar_utils_exports.findNodeForProperty(cst, "name");
+    if (!nameNode)
+      return [];
+    const chainNodes = grammar_utils_exports.findNodesForProperty(cst, "chainSegs");
+    const end = chainNodes.length > 0 ? chainNodes[chainNodes.length - 1].end : nameNode.end;
+    return this.segmentsInSpan(cst, nameNode.offset, end);
+  }
+  /** The path segments spelled between two offsets of `cst`, separators retained.
+   *  `$` is the root-namespace GlobalQualification prefix and carries no segment;
+   *  a `RelationSegment`'s own `[n]` multiplicity addresses the segment it follows
+   *  (`engine[2]`) and is likewise not one, so bracketed text is skipped whole. */
+  segmentsInSpan(cst, from, to) {
+    const segments = [];
+    let separator;
+    let bracketDepth = 0;
+    for (const leaf of cst_utils_exports.flattenCst(cst)) {
+      if (leaf.offset < from)
+        continue;
+      if (leaf.end > to)
+        break;
+      if (leaf.text === "[") {
+        bracketDepth += 1;
+        continue;
+      }
+      if (leaf.text === "]") {
+        bracketDepth = Math.max(0, bracketDepth - 1);
+        continue;
+      }
+      if (bracketDepth > 0)
+        continue;
+      if (leaf.text === "$")
+        continue;
+      if (leaf.text === "." || leaf.text === "::") {
+        separator = leaf.text;
+        continue;
+      }
+      segments.push({
+        text: canonicalEscapedName(leaf.text),
+        separator: segments.length === 0 ? void 0 : separator,
+        cst: leaf
+      });
+      separator = void 0;
+    }
+    return segments;
+  }
   resolveRoot(node, name, snapshot) {
     if (name === "self" || name === "this" || name === "that") {
       for (let owner = node.$container; owner; owner = owner.$container) {
@@ -59408,6 +59505,28 @@ var FeaturePathResolver = class {
   }
 };
 
+// ../language-server/out/src/services/namespace-kind.js
+var KERML_CLASSIFIER_DECL_TYPES = /* @__PURE__ */ new Set([
+  "AssociationDecl",
+  "BehaviorDecl",
+  "ClassDecl",
+  "ClassifierDecl",
+  "DatatypeDecl",
+  "FunctionDecl",
+  "InteractionDecl",
+  "MetaclassDecl",
+  "PredicateDecl",
+  "StructDecl",
+  "TypeDecl"
+]);
+function isNamespaceOnlyDecl(node) {
+  if (isPackage(node) || node.$type === "NamespaceDecl" || node.$type === "BareDefDecl")
+    return true;
+  if (KERML_CLASSIFIER_DECL_TYPES.has(node.$type))
+    return true;
+  return node.isDef === true;
+}
+
 // ../language-server/out/src/services/validator.js
 var severityOverrides = {};
 function setSeverityOverrides(overrides) {
@@ -59419,6 +59538,9 @@ function severity(code, defaultSeverity) {
 function isLibraryDocument2(node) {
   return isLibraryDocument(ast_utils_exports.getDocument(node));
 }
+function isDefinitionOnlyNode(node) {
+  return !isPackage(node) && isNamespaceOnlyDecl(node);
+}
 var TABLE_4_ESCAPES = /* @__PURE__ */ new Set(['"', "'", "\\", "b", "f", "t", "n"]);
 var IDENT_START = /[\p{L}_]/u;
 var IDENT_PART = /[\p{L}\p{N}_]/u;
@@ -59601,6 +59723,53 @@ var SysmlValidator = class _SysmlValidator {
       data: { featurePathSegment: true }
     });
   }
+  // REQ-389 — Namespace qualification versus feature chaining in every written path
+  // issue #213 — RES019: `::` binds tighter than `.`. Each dot-separated link of
+  // a KerML FeatureChain is a complete QualifiedName, and an
+  // `OwnedFeatureChaining::chainingFeature` is scoped to `[SysML::Feature|…]`,
+  // so only a USAGE may sit on the left of a dot; a Definition specializes
+  // Classifier and a package is a plain Namespace. `perform`, `exhibit` and
+  // every connector end reach the world through the same
+  // OwnedReferenceSubsetting, so one rule governs them all. This extension's
+  // permissive scoping resolves the dotted form regardless (a definition IS a
+  // Namespace), which is precisely why it is worth a warning rather than
+  // silence: the Pilot implementation refuses the same text at LINKING time, so
+  // the model is not portable. A warning, never an error — the text is
+  // well-formed here and the fix is mechanical.
+  checkChainSeparators(node, accept) {
+    const chainSegs = node.chainSegs;
+    if (!Array.isArray(chainSegs) || chainSegs.length === 0)
+      return;
+    this.reportChainSeparators(node, this.featurePaths.resolveDeclarationPath(node).segments, accept);
+  }
+  // REQ-389 — issue #213. A connector end (`connect`, `flow`, `bind`,
+  // `succession`, `interface`, `allocate`, the transition ends) keeps its whole
+  // path in one `RelationPath` datatype string, so there is no `chainSegs` list —
+  // but it reaches its target through the same OwnedReferenceSubsetting as
+  // `perform` and `exhibit`, and the rule does not change with the statement that
+  // carries it. `reference` is the `references` / `::>` tail, which is a second
+  // OwnedReferenceSubsetting on the same end and is judged the same way.
+  checkConnectorEndSeparators(node, accept) {
+    for (const property3 of ["path", "reference"]) {
+      const text = node[property3];
+      if (typeof text !== "string" || !text.includes("."))
+        continue;
+      this.reportChainSeparators(node, this.featurePaths.resolvePropertyPath(node, property3).segments, accept);
+    }
+  }
+  /** RES019 for one resolved path: the first non-final link that is chained with
+   *  `.` from something that can never be a Feature. */
+  reportChainSeparators(node, segments, accept) {
+    for (let index = 0; index + 1 < segments.length; index += 1) {
+      if (segments[index + 1].separator !== ".")
+        continue;
+      const owner = segments[index].target;
+      if (!owner || !isDefinitionOnlyNode(owner))
+        continue;
+      accept(severity("RES019", "warning"), DIAGNOSTIC_MESSAGES.RES019_DEFINITION_IN_FEATURE_CHAIN(segments[index].text, segments[index + 1].text), { node, range: segments[index].cst.range, code: "RES019" });
+      return;
+    }
+  }
   // REQ-169, REQ-329 — SSM001 def/usage mismatch for parts
   checkPartDecl(node, accept) {
     if (!node.isDef && node.name && /^[A-Z]/.test(node.name)) {
@@ -61465,6 +61634,11 @@ ${baseIndent}}`;
       Document: this.checkDocument.bind(this),
       PartDecl: this.checkPartDecl.bind(this),
       PathExpr: this.checkPathExpr.bind(this),
+      // issue #213 — RES019: the `::` vs `.` rule on the reference-form
+      // declarations that reach their target through OwnedReferenceSubsetting.
+      PerformStmt: this.checkChainSeparators.bind(this),
+      ExhibitStateDecl: this.checkChainSeparators.bind(this),
+      ConnectorEnd: this.checkConnectorEndSeparators.bind(this),
       RequirementDecl: this.checkRequirementDecl.bind(this),
       AttributeDecl: this.checkAttributeDecl.bind(this),
       ConstraintDecl: this.checkConstraintDecl.bind(this),
@@ -69105,7 +69279,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.15.2" : "dev";
+var VERSION2 = true ? "0.15.3" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {