Pilot: SysML v2 Pilot Implementation release 2026-08, commit 692170b71867353b8f90341e61556f49a5beb0e5, artifact jupyter-sysml-kernel 0.62.0 — the pin in scripts/pilot-pin.sh
Jar: jupyter-sysml-kernel-0.62.0-all.jar (sha256:b1ad9d64b1f0c75730facf25a5e2856bc9df2bb4bd39476df2fdf5ae68cd9350), provisioned by ./scripts/download-pilot-validator.sh
Run: go run -C tools ./cmd/validation-census (restates the Pilot, Jar and Census lines from the baseline); go run -C tools ./cmd/validation-census -check (the gate); go run -C tools ./cmd/validation-census -update (re-extracts the names from the jar, keeping every recorded status)
Baseline: validation-constraints-baseline.json — the constraint names read from the pinned jar, with the pin, the jar digest, the extraction method and each name's census status
Evidence: tools/census/validation/testdata/probes/ — one minimal violating model per implemented row, run by go test -C tools ./census/validation
Names: the file and type names quoted in the Implementation column are the code's own
identifiers, prefixes included (w8c_, W10B…); they name nothing outside the source tree, and a
reader who only wants the verdicts can ignore them.
The pilot validators name every constraint they check (validateNamespaceDistinguishability,
validateUsageType, …), OpenSysML does not: its diagnostics are worded for the reader and its
checks are grouped by pass, so before this census 157 of the pilot's names occurred nowhere in this repository. This
page is the map between the two. Not named is not not implemented — Duplicate of other owned member name is validateNamespaceDistinguishablity — and implemented is not named:
a row is ✅ or
Census: 163 of 217 named constraints are reported by OpenSysML — 157 ✅ faithful and 6
The figures on that line, and the pin and digest quoted above, are written by
go run -C tools ./cmd/validation-census from the baseline; -check fails on a hand-edited figure or
provenance value, on a table row the baseline does not record, on
a baseline name the table lacks, on an implemented row without a probe, on an implemented row's
Implementation cell that cites no internal/….go:function location, cites one whose
function or Type.method (generic receivers included) the named file does not declare, or
cites one that continues past the method (Type.method.extra), on a Negative case that does
not exist, whose header attributes the rejection (by its pilot validate… token or the specification constraint
cited before it) to a different constraint, or whose bucket in
pilot-rejection-baseline.json contradicts the row's status (a
✅ row's case must be one OpenSysML rejects, a ❌ row's one only the pilot rejects), on a corpus
case attributed to a constraint whose row does not list it, and — when the pinned
jar is present, or always with -require-jar — on a baseline that no longer lists what the jar
contains. It runs under make docs-counts; the jar comparison runs in the scheduled
oracle reproduction.
Same vocabulary as spec-compliance.md, plus one value for what has not been adjudicated:
- ✅ faithful — OpenSysML reports the violation with the pilot's meaning; the wording may differ (the Our message column says how).
⚠️ approximate — OpenSysML reports the violation, but narrower, wider, or from a different layer than the pilot (a parser diagnostic where the pilot validates, a warning where it errors, a subset of the cases).- ❌ not implemented — a model the pilot rejects under this constraint passes OpenSysML silently. This includes constraints the pilot grammar enforces (a syntax error there) where OpenSysML's parser accepts the form and its passes report nothing.
- ⛔ deliberate — OpenSysML declines the constraint on purpose (one at this recording:
validateClassifierMultiplicityDomain, which the pilot reports only on a model the specification's derivation leaves valid). - 🚧 known failure — implemented and known wrong (none at this recording).
- ❔ unknown — no case and no identifiable pass yet — no textual model was found that makes the pilot report the constraint, so there is nothing to map yet. Most of these are structural constraints on the abstract syntax that the textual notation cannot violate (an operator that is not
collect, a result parameter that is not owned), or constraints whose violation is a syntax error in both tools before either validator runs. They are not claimed either way.
Every ✅ and tools/census/validation/testdata/probes/<constraint>.{kerml,sysml}:
a minimal model that violates the constraint, headed by the constraint name and the severity and
message fragment OpenSysML must report for it. go test -C tools ./census/validation runs each probe
through the workspace and fails if the diagnostic is missing; -check fails if an implemented
row has no probe (a row both validators declare needs one probe per notation, .kerml and
.sysml, because the two mappings differ) or a probe names a row that is not implemented. The probes were also run through
the pinned pilot validators (build/pilot-sysml-validator/validate-sysml-batch,
build/pilot-kerml-validator/validate-kerml) to confirm the pilot reports the constraint the
row names on the same model; where it reports a different one, the Checks column says so.
The Negative case column names the file in tools/referee/reject/testdata/negative/ (see
pilot-rejection.md) that exercises the constraint against the pilot
oracle, or none where the corpus has no case yet; every case whose header attributes its
rejection to a pilot constraint (pilot validate…) is listed on that constraint's row. This
census adds no corpus cases.
tools/census/validation/jar.go opens the pinned jar, reads the two validator classes
(org/omg/kerml/xtext/validation/KerMLValidator.class,
org/omg/sysml/xtext/validation/SysMLValidator.class), parses each class file's constant pool
and keeps every CONSTANT_String matching ^(in)?validate[A-Za-z]+_?$. The Xtend sources
declare each constraint as a public constant whose string value is its name; the compiled
strings carry one trailing underscore for most SysML constraints (validateActionUsageType_)
and one KerML constant is misspelled invalidateMetadataFeatureBody, so the baseline records
the normalized name (the in prefix and one trailing underscore dropped) and, where they differ,
the raw compiled string. A name found in both classes has source both. The result is the same
217 names, with the same sources, as the hand-extracted list this census was commissioned
against. Four names are misspelled in the pilot itself and are recorded as spelled:
validateNamespaceDistinguishablity, validateEndFeatureMembershpIsEnd,
validateViewDefinitionOnlyOnvViewRendering, validateStateSubactionMembershioOwningType.
Constraints are grouped by language and listed in the baseline's (alphabetical) order.
Checks paraphrases the pilot's check and, where the pilot's message is not obvious from it,
quotes the message. Implementation is internal/check/passes/<file>.go:<func> or the
parser/resolver location. Our message is given only where OpenSysML's wording differs.
| Constraint | Language | Checks | Implementation | Our message | Negative case | Status |
|---|---|---|---|---|---|---|
validateAnnotationAnnotatedElementOwnership |
KerML | An annotation owned by its annotated element owns its annotating element (Must own its annotating element): textually, an annotating element whose about names itself — directly, beside other elements, through an alias, or as a metadata usage — owns an annotation whose annotated element is its own owner. The pilot's other branch (Must be owned by its annotated element, an annotation owning its annotating element from elsewhere) is grammar-unconstructable: an annotating element is only ever owned by the element its body sits in |
internal/check/passes/annotation_ownership.go:AnnotationOwnershipPass.Run | — | semantic/k48-annotating-element-annotates-itself.kerml |
✅ faithful |
validateAnnotationAnnotatingElement |
KerML | An annotation either owns or is owned by its annotating element (Must either own or be owned by its annotating element); grammar-unconstructable — the pilot builds an annotation only from an about clause (owned by the annotating element) or from an annotating element in the annotated element's body (owning it), never neither or both (KerMLValidator.checkAnnotation). Shapes tried (KerML and SysML): comment, doc and metadata annotating themselves, an alias, another element, their owner and a nested owner's member |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateAssociationBinarySpecialization |
KerML | An association with more than two ends cannot specialize a binary association (Cannot have more than two ends) |
internal/check/passes/constraint.go:checkBinaryConnectorEnds | A has 3 ends but specializes a binary link (Links::BinaryLink), which cannot have more than two; drop the extra ends or specialize an n-ary link instead — reported on each end past the second, counting declared, positional and inherited ends |
semantic/k24-binary-assoc-three-ends.kerml |
✅ faithful |
validateAssociationEndTypes |
KerML | Each association end has exactly one type | internal/check/passes/w8c_association_end_types.go:AssociationEndTypesPass.Run | — | xpect/p02-association-end-two-types.kerml |
✅ faithful |
validateAssociationRelatedTypes |
KerML | An association has at least two related types (Must have at least two related elements) |
internal/check/passes/w10b_related_elements.go:W10BRelatedElementsPass.Run | same wording; counts owned and inherited ends of a concrete assoc, assoc struct, interaction, connection def, interface def, allocation def or flow def |
semantic/k25-assoc-one-end.kerml |
✅ faithful |
validateAssociationStructureIntersection |
KerML | An association that is also a structure must be an association structure (Must be an association structure); the pilot has no check — KerMLValidator.checkAssociation notes the constraint is automatically satisfied, because oclIsKindOf(Structure) is a metaclass test the keyword (assoc vs assoc struct) fixes. Shapes tried: assoc struct specializing or conjugating a class, a structure, Links::Link, Base::Anything and Objects::Object; assoc specializing a structure |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateBehaviorSpecialization |
KerML | A behavior cannot specialize a structure | internal/check/passes/w11a_kerml_specialization.go:W11AKerMLSpecializationPass.Run | — | semantic/k23-behavior-specializes-struct.kerml |
✅ faithful |
validateBindingConnectorArgumentTypeConformance |
KerML | A binding connector's output feature conforms to its input feature (Output feature must conform to input feature); a no-op — the pilot's check is commented out in KerMLValidator.checkBindingConnector, marked This check is not currently implemented, so on a binding of non-conforming features both tools report validateBindingConnectorTypeConformance instead, and the warning the pilot draws on an operator or invocation argument (w + 1 with w : Wheel) is that same active rule run over the binding connector it synthesizes from the argument to the parameter, not this one. Shapes tried: binding of x = y between unrelated classes, a feature value feature w : A = y, a binding to a later-declared feature, a non-conforming operator and invocation argument |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateBindingConnectorIsBinary |
KerML | A binding connector relates exactly two features (Binding connector must be binary): a binding with a third owned end, with one end, with none, or an abstract one with none; inherited ends count, so binding b9 :> b2 of a binary b2 is fine |
internal/check/passes/w10b_related_elements.go:W10BRelatedElementsPass.Run | — | semantic/k49-binding-connector-with-three-ends.kerml |
✅ faithful |
validateBindingConnectorTypeConformance |
KerML | The two features a binding connector binds have conforming types, on the explicit bind/binding and on the bindings the language implies: a feature value to its feature, a result expression to the result parameter, a satisfy … by operand and a nested requirement's or case's subject to the subject they fill, and each operator or invocation argument to the parameter of the function it fills (warning) |
internal/check/passes/w9c_bound_feature_types.go:W9CBoundFeatureTypesPass.Run; internal/check/passes/typecheck_value.go:exprChecker.checkValueConformance; internal/check/passes/w9c_argument_bindings.go:exprChecker.judgeArgumentBinding | same wording and position for bind/binding (feature-chain ends included), result expressions, satisfy … by and nested subjects, and for an operator or invocation argument whose static type does not conform to the selected function's parameter (w + 1 and sum(masses) against a Real parameter, at the argument of an invocation and at the whole operator expression), with the same silence where the callee is unresolved or ambiguous, the argument's type unknown or collection-valued, or the parameter typed by a Collection or Element; and the same silence for a Boolean-valued { … } against BooleanEvaluation and an expression body against a feature typed by an Evaluation in either direction; the implicit binding of a feature value part x : D = c; or return : D = c; is the typechecker's error cannot bind a value of type C to a feature typed by D at the value where the pilot warns at the feature, and that check also judges a default value and a narrowing literal (attribute i : Integer = 1.5;), which the pilot leaves silent; a predicate's or bool's non-Boolean result expression is likewise the typechecker's error constraint expression must be Boolean, found D at the expression (internal/check/passes/typecheck_expr.go:exprChecker.checkBoolean) where the pilot warns at the predicate. Stays approximate: the value/feature typing judgment is the type tier's and a mismatch is an error there, so it cannot become the pilot's constraint-tier warning without letting the constraint tier run over an ill-typed model; the default and narrowing-literal cases the pilot leaves silent are spec-genuine. |
none | |
validateClassSpecialization |
both | A class (KerML) or an occurrence, port, action, state, calculation, constraint, requirement, case, metadata, view, connection, interface, flow or allocation definition (SysML) cannot specialize a data type or, unless it is itself an association, an association — through specializes or :>, and through a chain of generals only at the classifier that names the offending general |
internal/check/passes/w11a_kerml_specialization.go:W11AKerMLSpecializationPass.Run | same wording in both notations (Cannot specialize data type or association, Cannot specialize attribute definition) at the general |
semantic/k21-class-specializes-datatype.kerml |
✅ faithful |
validateClassifierDefaultSupertype |
KerML | A classifier directly or indirectly specializes its kind's default supertype (Must directly or indirectly specialize {supertype}); observable only through conjugation, which stops the pilot adding the implicit specialization (TypeAdapter.computeImplicitGeneralTypes): struct S ~ D with class D draws Objects::Object, function F ~ B with behavior B draws Performances::Evaluation, likewise a predicate, metaclass, association or interaction. assoc A ~ B { end feature a; end feature b; } draws Links::BinaryLink where the pilot's checkClassifier validates only the generic default and says Links::Link, assoc struct AS ~ Objects::LinkObject with two ends draws Objects::BinaryLinkObject where the pilot is silent, and interaction I ~ Links::Link with two ends draws Links::BinaryLink and Performances::Performance where the pilot (whose InteractionImpl maps to the association default alone) is silent — KerML 8.3.4.7 checkAssociationBinarySpecialization requires the binary base and a conjugated type owns no specialization to supply it (validateSpecializationSpecificNotConjugated), see omg-issues.md. Stays approximate: the Links::BinaryLink requirement is KerML §8.3.4.7 and is kept. |
internal/check/passes/w11e_implicit_base.go:implicitBaseChecker.checkDefaultSupertype | — | semantic/k46-conjugated-structure-not-an-object.kerml |
|
validateClassifierMultiplicityDomain |
KerML | A classifier's multiplicity has no featuring type (Multiplicity must not have a featuring type). The pilot reports it only for class C { alias m for K::f::m; } — its Type.multiplicity scans alias memberships and finds the feature's multiplicity — but KerML 8.3.3.1 derives multiplicity from ownedMember, which an alias's target is not, so that model is valid and OpenSysML declines to report it (filed as Systems-Modeling/SysML-v2-Pilot-Implementation#802; the report is in omg-issues.md). Every direct spelling is grammar-unconstructable: multiplicity admits no featured by, a multiplicity owned by a classifier has no featuring type, and a standalone featuring C::m by D leaves the pilot silent. Shapes tried: class C [2], an owned multiplicity m [3] in a class, data type, structure, association and behavior, featuring in every position, a classifier nested in a feature, an alias from a subclass |
— | — | none | ⛔ deliberate |
validateCollectExpressionOperator |
KerML | A collect expression's operator is collect (Operator must be 'collect'); derived-property — CollectExpressionImpl initializes operator to collect and the grammar builds a collect expression only from .{ }, so text cannot set another operator. Shapes tried: x.{in a; a.y}, x.z.{in a; a}, a chained x.y.?{...}.z, spaced x . y |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateConnectorBinarySpecialization |
KerML | A connector with more than two ends cannot specialize a binary connector (Cannot have more than two ends) |
internal/check/passes/constraint.go:checkBinaryConnectorEnds | c has 3 ends but specializes a binary link (Links::BinaryLink), which cannot have more than two; drop the extra ends or specialize an n-ary link instead — counts positional (x, y, z) and from … to ends, declared end features and inherited ends |
semantic/k26-binary-connector-three-ends.kerml |
✅ faithful |
validateConnectorRelatedFeatures |
KerML | A connector has at least two related features | internal/check/passes/w10b_related_elements.go:W10BRelatedElementsPass.Run | same wording; a parenthesized KerML end list with one end is a parse error (expected at least two connector ends in a parenthesized end list) |
xpect/p20-connection-with-one-end.sysml |
✅ faithful |
validateConnectorTypeFeaturing |
KerML | A connector's related features are accessible from its featuring type | internal/check/passes/w8d_connector_featuring.go:W8DConnectorFeaturingPass.Run | — | semantic/k27-connector-feature-outside-featuring-type.kerml |
✅ faithful |
validateConstructorExpressionNoDuplicateFeatureRedefinition |
KerML | A constructor expression binds each feature of the instantiated type at most once (Feature already bound) |
internal/check/passes/typecheck_expr.go:exprChecker.inferConstructor | x of C is already bound by an earlier argument — at the repeated label, including a label repeated qualified or through a redefinition |
semantic/k34-constructor-feature-bound-twice.kerml |
✅ faithful |
validateConstructorExpressionOwnedFeatures |
KerML | A constructor expression owns no feature but its result (ownedFeatures->excluding(result)->isEmpty(), Owned feature not allowed); the notation cannot violate it — the grammar places every argument under the result parameter (ConstructorResultMember), so the pilot never reports it on a textual model. A label naming no feature of the type (new C(y = t)) is the pilot's checkConstructorExpressionResultFeatureRedefinition (Must correspond to one feature of the instantiated type), a check the jar does not name as a validate… constraint; OpenSysML reports it as unresolved member: y and a positional argument past the type's constructible features as new C takes 1 argument(s), found 2 where the pilot only warns Bound features should have conforming types |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateCrossSubsettingCrossedFeature |
KerML | A cross subsetting chains through an opposite end feature: the crossed feature is a two-feature chain and, on a binary type, starts at the other end | internal/check/passes/w10b_cross_features.go:checkW10BCrossFeatures | — | semantic/k17-crosses-not-through-opposite-end.kerml |
✅ faithful |
validateCrossSubsettingCrossingFeature |
KerML | A cross subsetting is owned by one of two or more end features | internal/check/passes/w10b_cross_features.go:checkW10BCrossFeatures | — | semantic/k16-crosses-from-nonend.kerml |
✅ faithful |
validateDataTypeSpecialization |
both | A data type (KerML) or an attribute or enumeration definition (SysML) cannot specialize a class or association — through specializes or :> |
internal/check/passes/w11a_kerml_specialization.go:W11AKerMLSpecializationPass.Run | same wording in both notations (Cannot specialize class or association, Cannot specialize item definition for every SysML definition kind that is a class, as the pilot says) at the general |
semantic/k20-datatype-specializes-class.kerml |
✅ faithful |
validateElementFilterMembershipIsBoolean |
KerML | A filter condition has a Boolean result | internal/check/passes/filter.go:filterChecker.check | — | xpect/p12-filter-integer-condition.sysml, xpect/p21-filter-constructor-condition.sysml |
✅ faithful |
validateElementFilterMembershipIsModelLevelEvaluable |
KerML | A filter condition is model-level evaluable | internal/check/passes/filter.go:filterChecker.check | — | xpect/p22-filter-not-model-level-evaluable.sysml |
✅ faithful |
validateElementIsImpliedIncluded |
KerML | An element has no implied relationships unless marked as including them (Element cannot have implied relationships included); derived-property — isImplied relationships are created only by the pilot's own transformation (ElementUtil.transformAll), which sets isImpliedIncluded on the elements it gives them, so text never contradicts it. Shapes tried: subsetting, conjugation, connectors, bindings, successions, flows, invocations, redefinition, association ends, behavior parameters |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateEndFeatureMembershpIsEnd |
KerML | The feature of an end feature membership is an end feature (Must be an end feature; the pilot's constant is spelled Membershp); grammar-derived — an end feature membership is built only from the end prefix and EndFeatureMembershipAdapter.postProcess sets the member's isEnd, so the member is always an end feature. Shapes tried: end feature, const end feature, SysML end usages in connection and part definitions, an end redefined by a non-end feature |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateExpressionResultExpressionMembership |
KerML | An expression owns or inherits at most one result expression — a body listing two bare expressions states two (calc c { 1 2 }), and a usage typed by, subsetting, reference-subsetting or redefining one that owns a body inherits that result expression and may not state a second (calc c : C { x + 2 }, constraint :>> c { x > 1 }, constraint d ::> c { x > 1 }); an empty or doc-only redefinition keeps the inherited one |
internal/check/passes/w8c_result_expression.go:ResultExpressionPass.Run over internal/semantic/semantics/result_expression.go:Model.ResultExpressionConflict | — | semantic/k30-expr-inherits-second-result-expression.kerml, semantic/k43-expr-typed-by-function-states-second-result-expression.kerml, semantic/k44-expr-referencing-expr-states-second-result-expression.kerml, semantic/s83-redefined-constraint-usage-states-second-result-expression.sysml, semantic/s84-referencing-constraint-usage-states-second-result-expression.sysml |
✅ faithful |
validateExpressionResultParameterMembership |
KerML | An expression owns at most one return parameter | internal/check/passes/w10b_structural.go:W10BStructuralPass.Run | — | semantic/k28-expr-two-return-parameters.kerml |
✅ faithful |
validateFeatureChainExpressionFeatureConformance |
KerML | The target feature of a feature-chain expression is a feature of the source's type (Must be a valid feature); the pilot also reports the unresolved chain target from name resolution |
internal/check/passes/w8c_feature_reference.go:FeatureReferencePass.Run | — | semantic/k41-chain-expression-to-nested-class.kerml |
✅ faithful |
validateFeatureChainExpressionOperator |
KerML | A feature-chain expression's operator is . (Operator must be '.'); derived-property — FeatureChainExpressionImpl initializes operator to . and the grammar builds a feature-chain expression only from ., so text cannot set another operator. Shapes tried: x.y, x.z.y, a chain through a select or collect, spaced x . y |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateFeatureChainingFeatureConformance |
KerML | Each chaining feature of a feature chain is featured within the one before it (Must be a valid feature): a chain k.z where z is an alias in k's type for another type's feature, written as a references, chains or :> target or as a connector, binding or succession end; a chain through a genuinely featured member (k.w.y) is fine |
internal/check/passes/w8c_feature_reference.go:featureReferenceChecker.checkDeclaredChains | — | semantic/k47-feature-chain-through-alias-to-another-type.kerml |
✅ faithful |
validateFeatureChainingFeatureNotOne |
KerML | A feature chain has more than one chaining feature | internal/check/passes/w8c_type_relationships.go:TypeRelationshipsPass.Run | — | xpect/p05-single-chaining-feature.kerml |
✅ faithful |
validateFeatureChainingFeaturesNotSelf |
KerML | A feature is not one of its own chaining features (Feature cannot have itself in a feature chain) |
internal/check/passes/w8c_type_relationships.go:TypeRelationshipsPass.Run | — | semantic/k12-chain-through-self.kerml |
✅ faithful |
validateFeatureConstantIsVariable |
KerML | Only a variable feature can be constant | internal/check/passes/w8c_variable_feature.go:VariableFeaturePass.Run | same wording; KerML const implies var, so only SysML's constant prefix on a usage that cannot time-vary violates it |
semantic/s80-constant-attribute-not-variable.sysml |
✅ faithful |
validateFeatureCrossFeatureSpecialization |
KerML | A cross feature specializes the cross features of the ends it redefines, explicitly or through the implicit redefines of an end in an association that specializes another |
internal/check/passes/w10b_cross_features.go:checkW10BCrossFeatures | — | semantic/k19-cross-feature-not-specializing.kerml |
✅ faithful |
validateFeatureCrossFeatureType |
KerML | A cross feature has the same types as its feature (KerML Feature::type: declared, subsetted, redefined and referenced features' types, the most specific kept), an untyped feature being typed by Anything and an owned cross feature by its end |
internal/check/passes/w10b_cross_features.go:checkW10BCrossFeatures | — | semantic/k18-cross-feature-type-differs.kerml, semantic/k54-cross-feature-typed-narrower-than-end.kerml, semantic/s88-cross-feature-typed-narrower-than-end.sysml |
✅ faithful |
validateFeatureEndFeatureMultiplicity |
KerML | An end feature has multiplicity 1 (warning End feature must have multiplicity 1): none of the end's multiplicities — its own, or one inherited through subsetting, redefinition, typing, a reference or an implicit end — is exactly 1..1; an unevaluable bound counts as omitted ([n..1] is silent). In SysML an end usage defaults to 1..1, so only a declared own non-1..1 multiplicity warns; the [m] of end [m] item x : A is the cross feature's and is silent |
internal/check/passes/end_multiplicity.go:constraintChecker.checkFeatureEndFeatureMultiplicity | same wording, followed by the fix: write [1] or take it from a feature the end subsets or redefines |
none | ✅ faithful |
validateFeatureEndIsConstant |
KerML | A variable end feature is constant (End feature must be constant); declared but a no-op — KerMLValidator defines the constant and message but no @Check references them, and neither grammar admits var on an end feature. Shapes tried: end constant a and end a in SysML connection and part definitions, const end feature and end feature in KerML associations, an end redefinition |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateFeatureEndNoDirection |
KerML | An end feature has no direction (End feature cannot have direction): SysML end in a, end out a, end inout a in a connection or part definition, or redefining an end; KerML's EndFeaturePrefix admits no direction, so the KerML spelling is grammar-unconstructable and the probe is SysML |
internal/check/passes/end_feature.go:EndFeaturePass.Run | — | semantic/s86-end-with-direction.sysml |
✅ faithful |
validateFeatureEndNotDerivedAbstractCompositeOrPortion |
KerML | An end feature is not derived, abstract, composite or portion (End feature cannot be derived, abstract, composite or portion): SysML end derived a, end abstract a, end variation a (a variation is abstract); KerML's EndFeaturePrefix admits none of the four, and a SysML end part a is not composite in either tool, so the probe is SysML and the composite and portion halves are grammar-unconstructable |
internal/check/passes/end_feature.go:EndFeaturePass.Run | — | semantic/s87-end-derived-or-abstract.sysml |
✅ faithful |
validateFeatureHasType |
KerML | A feature has at least one type (Features must have at least one type); observable only through conjugation, which stops the pilot adding the implicit Base::things subsetting that types every plain feature f;: feature f ~ D with class D, nested class C { feature g ~ D; }, a step or expr conjugating a class; feature f2 ~ f1 of a typed f1 is fine |
internal/check/passes/w11e_implicit_base.go:implicitBaseChecker.checkFeatureHasType | — | semantic/k45-conjugated-feature-without-type.kerml |
✅ faithful |
validateFeatureIsVariable |
KerML | A variable feature is owned by an occurrence type | internal/check/passes/w8c_variable_feature.go:VariableFeaturePass.Run | — | xpect/p03-variable-in-datatype.kerml |
✅ faithful |
validateFeatureMultiplicityDomain |
KerML | A feature's multiplicity has the same featuring types as the feature (Multiplicity must have same featuring types as it feature). The genuine violation is a standalone featuring of C::x::m by D; on a feature-owned multiplicity; OpenSysML reports it on the featuring relationship member, while a target that is the feature's owner or specializes it is accepted. The pinned pilot is silent on this genuine form because its featuringType reads only owned type featurings. Its only observable trigger is the defective alias/reference derivation recorded in omg-issues.md and filed as Systems-Modeling/SysML-v2-Pilot-Implementation#802, which stays a valid model here. |
internal/check/passes/multiplicity_domain.go:MultiplicityDomainPass.Run | same wording | none | ✅ faithful |
validateFeatureOwnedCrossSubsetting |
KerML | A feature owns at most one cross subsetting; the 2026-07 pilot crashed on the probe with Error executing EValidator instead of reporting it, fixed upstream at 2026-08 (see omg-issues.md) |
internal/check/passes/w10b_cross_features.go:checkW10BCrossFeatures | At most one cross subsetting is allowed — the message the pilot's source intends |
semantic/k42-two-cross-subsettings.kerml |
✅ faithful |
validateFeatureOwnedReferenceSubsetting |
KerML | A feature owns at most one reference subsetting | internal/check/passes/w8c_reference_subsetting.go:ReferenceSubsettingPass.Run | — | semantic/k09-two-reference-subsettings.kerml |
✅ faithful |
validateFeaturePortionNotVariable |
KerML | A portion feature is not variable | internal/check/passes/w8c_variable_feature.go:VariableFeaturePass.Run | — | semantic/k10-portion-var-feature.kerml |
✅ faithful |
validateFeatureReferenceExpressionReferentIsFeature |
KerML | The referent of a feature reference expression is a feature | internal/check/passes/w8c_feature_reference.go:FeatureReferencePass.Run | — | semantic/k39-feature-reference-to-class.kerml |
✅ faithful |
validateFeatureReferenceExpressionResult |
KerML | A feature reference expression owns its result parameter (Must own its result parameter); derived-property based: the pilot's FeatureReferenceExpressionAdapter.addAdditionalMembers adds the result parameter before validation, so no textual reference (= x, a chain, a bound, an argument, a body result) can lack one |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateFeatureValueIsInitial |
KerML | A feature with an initial value is variable (Initialized feature must be variable) |
internal/check/passes/w8c_variable_feature.go:VariableFeaturePass.Run | same wording, on the := value; the variability read is semantics.Model.FeatureIsVariable |
semantic/k11-initial-value-nonvariable.kerml |
✅ faithful |
validateFeatureValueOverriding |
KerML | A feature value does not override a binding feature value inherited from a redefined feature (Cannot override a binding feature value) |
internal/check/passes/feature_value_overriding.go:constraintChecker.checkFeatureValueOverriding (run by ConstraintPass.Run) | cannot override the binding value of P::a: a value written with `` = `` is fixed for every feature redefining it; write it as `` default = `` on P::a to allow overriding, or remove this value |
semantic/s46-feature-value-overriding.sysml |
✅ faithful |
validateFlowEndImplicitSubsetting |
KerML | A flow end whose owned feature is identified implicitly should use dot notation (warning Flow ends should use dot notation at each end); the pilot reports it when the end names a feature nested in a sibling feature by :: or by its plain name (flow f from a::o to b::i; with feature a { out feature o; }, and flow from x to y inside the owner of x and y), in KerML and SysML, inherited ends included, and errors Must have at least two related elements on the flow besides. OpenSysML rejects the same ends as inaccessible from the flow's featuring type (an error, from validateConnectorTypeFeaturing), or with a flow end must name the feature the payload flows from or to using dot notation for the plain-name form |
internal/check/passes/w8d_connector_featuring.go:W8DConnectorFeaturingPass.Run | Must be an accessible feature (use dot notation for nesting) — an error where the pilot warns. Stays approximate: the same end is already rejected here as an inaccessible feature; adding the pilot's warning beside that error would report one defect twice at one span. |
none | |
validateFlowEndIsEnd |
KerML | A flow end is an end feature (Must be an end feature); grammar-unconstructable: the pilot builds a FlowEnd only through FlowEndMember (an EndFeatureMembership), and EndFeatureMembershipAdapter.postProcess sets isEnd on the member, so every textual flow end (from/to, the flow a.o to b.i shorthand, succession flow, message) is an end feature; no keyword spells a flow end elsewhere |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateFlowEndNestedFeature |
KerML | A flow end has exactly one nested input or output feature (Flow end must have a nested input or output feature); grammar-unconstructable: the pilot's FlowEnd production is FlowEndSubsetting? FlowFeatureMember — exactly one owned feature, no body — so a flow end cannot be written with zero or two; tried the dot, ::, plain-name, chain, shorthand and succession flow spellings, which report validateFlowEndSubsetting, validateFlowEndImplicitSubsetting or validateConnectorTypeFeaturing instead |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateFlowEndOwningType |
KerML | A flow end is owned by a flow (Flow end not allowed); grammar-unconstructable: FlowEndMember appears only inside FlowDeclaration (KerML) and FlowUsage/MessageDeclaration (SysML), so a flow end cannot be written under any other owner; end features of connectors and associations are Features, not FlowEnds |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateFlowEndSubsetting |
KerML | A flow end names the feature the payload flows from or to (Cannot identify flow end (use dot notation)) |
internal/check/passes/w8d_flow_end.go:W8DFlowEndPass.Run | same wording; a flow end without dot notation is additionally reported by internal/check/passes/constraint.go:checkFlowEndSubsetting |
semantic/k38-flow-end-without-dot-notation.kerml |
✅ faithful |
validateFlowItemFeature |
KerML | A flow has at most one item feature (Only one item feature is allowed); grammar-unconstructable: FlowDeclaration admits one of payload clause (( 'of' PayloadFeatureMember )?) and a PayloadFeature has no other spelling — a second of is a syntax error in both tools, and a feature in the flow body is an ordinary owned feature |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateFunctionResultExpressionMembership |
KerML | A function owns or inherits at most one result expression — a specialization of one that owns a body (constraint def Sub :> Base { x > 1 }, calc def D :> C { x + 2 }, predicate Sub specializes Base { … }) inherits that result expression and may not state a second, as may not a body listing two bare expressions (calc def C { in x; x + 1 x + 2 }); two generals each owning one are reported at the declaration, a requirement, concern or viewpoint being a constraint (viewpoint def V :> A, B;) |
internal/check/passes/w8c_result_expression.go:ResultExpressionPass.Run over internal/semantic/semantics/result_expression.go:Model.ResultExpressionConflict | — | semantic/k29-function-inherits-second-result-expression.kerml, semantic/s82-constraint-specialization-states-second-result-expression.sysml, semantic/s85-viewpoint-inherits-second-result-expression.sysml |
✅ faithful |
validateFunctionResultParameterMembership |
KerML | A function owns at most one return parameter | internal/check/passes/w10b_structural.go:W10BStructuralPass.Run | — | xpect/p17-calc-two-return-parameters.sysml |
✅ faithful |
validateImportTopLevelVisibility |
KerML | A top-level import is private | internal/check/passes/w8c_import_visibility.go:TopLevelImportPass.Run | — | xpect/p01-public-root-import.kerml |
✅ faithful |
validateIndexExpressionOperator |
KerML | An index expression's operator is # (Operator must be '#'); derived-property based: the pilot grammar builds an IndexExpression only from x#(i) and IndexExpressionImpl fixes its operator to #, while x[i] is an OperatorExpression (reported by validateOperatorExpressionBracketOperator) and '#'(x, i) an invocation |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateInstantiationExpressionInstantiatedType |
KerML | An instantiation expression names an instantiated type (Must have an invoked/instantiated type; a probe naming nothing fails name resolution first in both tools, so the probe names a package) |
internal/check/passes/typecheck_expr.go:exprChecker.inferConstructor | same wording, followed by what the name is (Q is a package, not a type) |
semantic/send-constructor-non-type.sysml |
✅ faithful |
validateInstantiationExpressionResult |
KerML | An instantiation expression owns its result parameter (Must own its result parameter); derived-property based: the pilot's InvocationExpressionAdapter and ConstructorExpressionAdapter add the result parameter in addAdditionalMembers before validation, so no textual invocation (f(1), new T(...), x->f {...}, a body argument, a chain head) can lack one |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateInvocationExpressionInstantiatedType |
KerML | An invocation expression invokes a behavior or a behavioral feature | internal/check/passes/typecheck_expr.go:inferInvocation | — | semantic/k31-invoke-class.kerml, semantic/send-payload-non-behavior.sysml |
✅ faithful |
validateInvocationExpressionNoDuplicateParameterRedefinition |
KerML | An invocation expression binds each parameter at most once (Parameter already bound) |
internal/check/passes/typecheck_expr.go:checkNamedArguments | F binds parameter "x" twice — the duplicate is found by the resolved parameter (a positional argument followed by a named binding of the same parameter, an alias or a redefining name count), reported at the second binding |
semantic/k33-parameter-bound-twice.kerml |
✅ faithful |
validateInvocationExpressionOwnedFeatures |
KerML | Each owned feature of an invocation expression is an in parameter (Must be an in parameter); grammar-unconstructable: the pilot's ArgumentList production (KerMLExpressions.xtext) writes every argument as an ArgumentMember or NamedArgumentMember, a ParameterMembership whose ParameterMembershipAdapter.postProcess sets direction in, a FunctionReferenceExpression or body argument becomes an in parameter's value, and an invocation has no body of its own; a named argument f(y = 1) naming an out parameter reports validateInvocationExpressionParameterRedefinition (Must correspond to one input parameter of the invoked type) instead |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateInvocationExpressionParameterRedefinition |
KerML | Each input argument of an invocation redefines exactly one input parameter of the invoked type (Must correspond to one input parameter of the invoked type): a named argument that names no in parameter (an out or return parameter, a general's parameter the invoked function's own parameter redefines by position), or a positional argument past the last in parameter |
internal/check/passes/typecheck_expr.go:exprChecker.checkArguments; internal/check/passes/typecheck_expr.go:exprChecker.checkNamedArguments | same wording at the argument, followed by the cause (Must correspond to one input parameter of the invoked type: F has no parameter named "y", …: F takes 2 argument(s), found 3 at the first excess argument); the invoked type may be a behavior or a feature typed by one |
semantic/k32-too-many-arguments.kerml |
✅ faithful |
validateLibraryPackageNotStandard |
KerML | A user library package is not marked standard (warning) | internal/check/passes/w9c_owned_name_and_library.go:W9CUserStandardLibraryPass.Run | — | none | ✅ faithful |
validateMetadataFeatureAnnotatedElement |
KerML | Each annotated element's metaclass conforms to the types of the metaclass's effective annotatedElement features — declared, inherited or redefined through the reflective KerML library — for both @M and @M about … (Cannot annotate {kind}) |
internal/check/passes/w8c_metadata_annotation.go:MetadataAnnotationPass.Run | — | semantic/k35-metadata-annotates-wrong-kind.kerml |
✅ faithful |
validateMetadataFeatureBody |
KerML | A feature in a metadata feature's body, at any nesting depth and in the @M about … form too, redefines a feature of a type the metadata type conforms to (the pilot's constant is spelled invalidateMetadataFeatureBody) |
internal/check/passes/w8c_metadata_annotation.go:MetadataAnnotationPass.Run; internal/check/passes/w8d_metadata_usage.go:W8DMetadataUsagePass.Run | — | semantic/k36-metadata-body-redefines-outside.kerml |
✅ faithful |
validateMetadataFeatureMetadata |
KerML | A metadata feature is typed by exactly one metaclass; a class, structure, data type or other non-metaclass type is rejected (Must have exactly one metaclass); on the negative case the pilot reports validateMetadataFeatureMetadataNotAbstract instead, because its grammar links @M only to a metaclass and the unlinked feature keeps only the implicit abstract Metaobject type |
internal/check/passes/w8c_metadata_type.go:MetadataTypePass.Run | — | semantic/k40-metadata-typed-by-class.kerml |
✅ faithful |
validateMetadataFeatureMetadataNotAbstract |
KerML | A metadata feature's metaclass is not abstract (Must have a concrete type); also what the pilot reports for a metadata feature typed by a non-metaclass, see validateMetadataFeatureMetadata |
internal/check/passes/w8c_metadata_type.go:MetadataTypePass.Run | — | xpect/p24-metadata-abstract-type.sysml, semantic/k40-metadata-typed-by-class.kerml |
✅ faithful |
validateMultiplicityRangeBounds |
KerML | A multiplicity range's bound expressions are its first two owned members (Bound expressions must be first two owned members); grammar-unconstructable: the pilot's MultiplicityBounds/MultiplicityRange productions write the bound OwningMemberships first and admit nothing before them, and a multiplicity m [..] { … } body member follows the bounds; [1..2], [*], [1..*], a body holding a feature or a doc comment, and a multiplicity with no bounds (subsets only) all validate clean in both tools |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateMultiplicityRangeResultTypes |
KerML | Multiplicity bounds have Natural values | internal/check/passes/w8c_multiplicity_bounds.go:MultiplicityBoundsPass.Run | same wording; a bound whose result type resolves to anything but an Integer-conforming data type is rejected, including a feature typed by a class; an unresolved or untyped bound stays silent | semantic/k37-multiplicity-bound-not-natural.kerml |
✅ faithful |
validateNamespaceDistinguishablity |
KerML | Owned member names of a namespace are distinguishable (warning; the pilot's constant is spelled Distinguishablity) |
internal/semantic/resolve/distinguishability.go:checkOwnedNames | — | none | ✅ faithful |
validateOperatorExpressionBracketOperator |
KerML | [ as an operator should be #(...) indexing (warning Use #(...) for indexing); not in the specification, which gives [ no function in KerML |
internal/check/passes/typecheck_expr.go:exprChecker.checkBracket | `x[i]` is not an index in KerML: `[` invokes BaseFunctions::'[', which the kernel library leaves abstract; index a sequence with `x#(i)` — every bracket in a .kerml document, at the operator expression; a .sysml document is judged by validateOperatorExpressionQuantity instead |
none | ✅ faithful |
validateOperatorExpressionCastConformance |
KerML | A cast (as) argument has a type conforming to the target (warning Cast argument should have conforming types) |
internal/check/passes/typecheck_expr.go:exprChecker.checkCast; internal/semantic/semantics/operator_conformance.go:Model.CastConformance | cast argument is typed by A, unrelated to the target C: neither type specializes the other, so the cast selects no value — as the pilot, either direction of specialization between any type of the argument (all its typings, inherited and redefined ones included) and the target conforms; an argument whose type is not statically known is silent; also reported in SysML documents, which declare the same operator |
none | ✅ faithful |
validateOwnedDifferencingNotOne |
KerML | A type does not difference exactly one type | internal/check/passes/w8c_type_relationships.go:TypeRelationshipsPass.Run | — | semantic/k02-differences-one-type.kerml |
✅ faithful |
validateOwnedIntersectingNotOne |
KerML | A type does not intersect exactly one type | internal/check/passes/w8c_type_relationships.go:TypeRelationshipsPass.Run | — | semantic/k03-intersects-one-type.kerml |
✅ faithful |
validateOwnedUnioningNotOne |
KerML | A type does not union exactly one type | internal/check/passes/w8c_type_relationships.go:TypeRelationshipsPass.Run | — | semantic/k04-unions-one-type.kerml |
✅ faithful |
validateParameterMembershipDirection |
KerML | A parameter has the direction its membership requires (Must have direction '{direction}'); derived-property based: the pilot's ParameterMembershipAdapter.postProcess overwrites the member's direction with the membership's (in for an argument or body parameter, out for a return), so a textual argument or return can never disagree — function F { return in r : Integer = 1; } and the SysML calc def spelling validate clean in both tools; a directed feature of a behavior is written through an ordinary FeatureMembership, which the check does not visit |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateParameterMembershipOwningType |
KerML | A parameter membership is owned by a behavior or a step (Parameter membership not allowed); grammar-unconstructable: the pilot's grammar writes a ParameterMembership only from an expression's arguments, body parameters and type references (owner: the expression) and from SysML action-node parameters (owner: the action usage), never from a direction keyword — class C { in feature x; } is an ordinary FeatureMembership and validates clean in both tools; the constructor-result case is ExpressionUtil.isConstructorResult |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateRedefinitionDirectionConformance |
KerML | A redefining feature has a direction compatible with the redefined feature | internal/check/passes/w8b_redefinition_conformance.go:RedefinitionDirectionPass.Run | — | xpect/p31-redefinition-incompatible-direction.sysml |
✅ faithful |
validateRedefinitionEndConformance |
KerML | A feature redefining an end feature is an end feature | internal/check/passes/w10b_redefinition.go:checkW10BRedefinition | — | semantic/k15-nonend-redefines-end.kerml |
✅ faithful |
validateRedefinitionFeaturingTypes |
KerML | A redefined feature is not package-level and the redefining and redefined features have different featuring types | internal/check/passes/w10b_redefinition.go:checkW10BRedefinition | — | xpect/p28-package-level-feature-redefined.sysml, xpect/p32-redefinition-same-featuring-type.sysml |
✅ faithful |
validateRedefinitionMultiplicityConformance |
KerML | A redefining feature does not weaken the redefined feature's lower bound (warning) | internal/check/passes/multiplicity_conformance.go:constraintChecker.checkMultiplicityConformance | — | none | ✅ faithful |
validateResultExpressionMembershipOwningType |
KerML | A result expression membership is owned by a function or expression (Result expression not allowed); grammar-unconstructable: the pilot's ResultExpressionMember appears only in FunctionBodyPart, a body expression and the SysML CalculationBodyPart/CaseBody (functions, expressions, predicates, calc, constraint and case definitions, all Functions), so a trailing expression in a class, feature, behavior, step, connector or package body is a syntax error in both tools (no viable alternative at input '1' / expected a body member) before either validator runs |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateReturnParameterMembershipOwningType |
KerML | A return parameter membership is owned by a function or expression (Return parameter membership not allowed); the pilot grammar rejects return elsewhere as a syntax error, OpenSysML's parser accepts it and the constraint reports it in a classifier, class, struct, behavior, step or SysML definition/usage that is no calculation, constraint, requirement or case |
internal/check/passes/return_parameter.go:constraintChecker.checkReturnParameterOwner | same wording, followed by the fix: write out for an output |
semantic/k51-return-parameter-in-classifier.kerml |
✅ faithful |
validateSelectExpressionOperator |
KerML | A select expression's operator is select (Operator must be 'select'); derived-property based: the pilot grammar builds a SelectExpression only from x.?{…} and SelectExpressionImpl fixes its operator to select, while x->select {…} and x.{…} are an InvocationExpression and a CollectExpression |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateSpecializationSpecificNotConjugated |
KerML | A conjugated type is not the specific type of a specialization: a standalone specialization subtype, subset, redefinition or typing element whose specific is a conjugated type or feature |
internal/check/passes/w11e_conjugated_specialization.go:W11EConjugatedSpecializationPass.Run | same wording, at the specific; the pilot places the subset, redefinition and typing findings at the start of the specialization element, having no such attribute to point at | semantic/k08-conjugated-type-specialized.kerml |
✅ faithful |
validateStructureSpecialization |
KerML | A structure cannot specialize a behavior | internal/check/passes/w11a_kerml_specialization.go:W11AKerMLSpecializationPass.Run | — | semantic/k22-struct-specializes-behavior.kerml |
✅ faithful |
validateSubsettingConstantConformance |
KerML | A feature subsetting a constant feature is constant (Subsetting/redefining feature must be constant if subsetted/redefined feature is constant) |
internal/check/passes/w8b_redefinition_conformance.go:RedefinitionConformancePass.Run | — | semantic/k14-variable-subsets-constant.kerml |
✅ faithful |
validateSubsettingFeaturingTypes |
KerML | A subsetted feature is accessible from the subsetting feature's featuring types | internal/check/passes/subsetting_featuring.go:checkSubsettingFeaturingTypes | — | semantic/k13-subsets-inaccessible-feature.kerml |
✅ faithful |
validateSubsettingMultiplicityConformance |
KerML | A subsetting feature does not widen the subsetted feature's upper bound (warning) | internal/check/passes/multiplicity_conformance.go:constraintChecker.checkMultiplicityConformance | — | none | ✅ faithful |
validateSubsettingPortionConformance |
KerML | A feature subsetting a portion feature is a portion (Subsetting/redefining feature must be portion if subsetted/redefined feature is portion); no-op: the pinned KerMLValidator declares the constant and its message but checkSubsetting never reports it, so feature q :> p; against portion feature p : Occurrence — in the same class, in a nested feature, inherited (:> p and :>> p in a subclass) — and the SysML part q :> s; against snapshot s/timeslice t usages validate clean in both notations; OpenSysML has no check either |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateSubsettingUniquenessConformance |
KerML | A nonunique feature does not subset or redefine a unique feature | internal/check/passes/w8b_redefinition_conformance.go:RedefinitionConformancePass.Run | — | xpect/p04-nonunique-subsets-unique.kerml |
✅ faithful |
validateTypeAtMostOneConjugator |
KerML | A type has at most one conjugator (Cannot have more than one conjugator); the pilot grammar rejects a second ~ as a syntax error, OpenSysML's parser accepts it and the constraint reports every conjugation past the first on a classifier, feature or SysML definition/usage |
internal/check/passes/conjugator.go:constraintChecker.checkAtMostOneConjugator | same wording, followed by the fix: remove the other ~ |
semantic/k52-two-conjugators.kerml |
✅ faithful |
validateTypeDifferencingTypesNotSelf |
KerML | A type does not difference itself | internal/check/passes/w8c_type_relationships.go:TypeRelationshipsPass.Run | — | semantic/k05-differences-self.kerml |
✅ faithful |
validateTypeIntersectingTypesNotSelf |
KerML | A type does not intersect itself | internal/check/passes/w8c_type_relationships.go:TypeRelationshipsPass.Run | — | semantic/k06-intersects-self.kerml |
✅ faithful |
validateTypeOwnedMultiplicity |
KerML | A type owns at most one multiplicity | internal/check/passes/at_most_one_member.go:checkAtMostOneMultiplicity | — | semantic/k01-two-owned-multiplicities.kerml |
✅ faithful |
validateTypeUnioningTypesNotSelf |
KerML | A type does not union itself | internal/check/passes/w8c_type_relationships.go:TypeRelationshipsPass.Run | — | semantic/k07-unions-self.kerml |
✅ faithful |
validateAcceptActionUsageParameters |
SysML | An accept action has an input parameter (An accept action must have a payload parameter.; SysMLValidator.checkAcceptActionUsage tests inputParameters.empty). Grammar-unconstructable: AcceptParameterPart always parses a PayloadParameterMember, a ParameterMembership whose parameter ParameterMembershipAdapter.postProcess sets to direction in, so inputParameters (UsageUtil.getOwnedInputParametersOf: the owned features directed in/inout) is never empty. Tried against the pinned validator: accept x : Sig, accept Sig, accept :>> q.pl, accept after/at/when triggers, accept … via q, { out o : Integer; } and { out :>> x; } bodies, accept x : Sig[0], action a : Sig accept …, transition triggers (transition first s1 accept Sig then s2, state s3; accept Sig then s2;), entry/do/exit accept Sig;, and the payload-less spellings accept;, accept via q;, entry accept; — the pilot reports nothing or another constraint on the well-formed ones and a syntax error (no viable alternative at input 'accept') on the payload-less ones, which OpenSysML's parser also rejects (expected the payload of the accept: …) |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateActionUsageType |
SysML | An action is typed by action definitions | internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | semantic/s01-action-typed-by-part-def.sysml |
✅ faithful |
validateActorMembershipOwningType |
SysML | Only requirements and cases have actors; the pilot grammar rejects actor elsewhere (mismatched input 'actor' expecting '}') |
internal/syntax/parser/defusage.go:Parser.misplacedMember (syntax tier, like the pilot) | 'actor' declares an actor of a requirement or case and is only allowed in a requirement or case body; move it into the requirement or case it belongs to |
grammar/g61-actor-outside-requirement-body.sysml |
✅ faithful |
validateAllocationUsageType |
SysML | An allocation is typed by allocation definitions | internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | semantic/s02-allocation-typed-by-connection-def.sysml |
✅ faithful |
validateAnalysisCaseUsageType |
SysML | An analysis case is typed by one analysis case definition | internal/check/passes/one_type.go:checkOneType | — | semantic/s03-analysis-typed-by-case-def.sysml |
✅ faithful |
validateAssertConstraintUsageReference |
SysML | An assert constraint usage references a constraint (Must reference a constraint.): assert c, assert not c, a feature chain (its last feature decides) and an inherited constraint alike, whether stated as a usage or inside a constraint body; a requirement usage is a constraint usage; an unnamed assertion derives no member name, so h.q written outside part h : H { assert q; } still reaches H::q |
internal/check/passes/typecheck.go:referenceKindMessage (shared with validateSatisfyRequirementUsageReference; chains through internal/check/passes/typecheck.go:typeChecker.checkChainReferenceKind; constraint-body members through internal/check/passes/typecheck.go:typeChecker.checkBehaviorMember) |
assert target must be a constraint usage, found partUsage |
semantic/s04-assert-references-non-constraint.sysml, semantic/s93-assert-through-owner-of-unnamed-assertion.sysml |
✅ faithful |
validateAssignmentActionUsageArguments |
SysML | An assignment action has two arguments (An assignment must have two arguments.). A no-op in the pinned pilot: SysMLValidator.xtend declares the constant (INVALID_ASSIGNMENT_ACTION_USAGE_ARGUMENTS, the string this census reads from the jar) but no @Check method issues it — checkAssignmentActionUsage reports only validateAssignmentActionUsageReferent and validateAssignmentActionUsageReferentIsTimeVarying — and AssignmentNodeDeclaration always parses both the AssignmentTargetMember and the := NodeParameterMember. Tried assign n := 1, assign q.pl := q.pl, assign n := n + 1, action a assign n := n, and the one-argument spellings assign n;, assign := 1;, assign n := ;, assign n := 1 := 2;: never reported; the one-argument spellings are syntax errors in both tools (pilot no viable alternative at input 'assign', OpenSysML expected ':=' after assignment target / expected an expression) |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateAssignmentActionUsageReferent |
SysML | An assignment action has a referent (An assignment must have a referent.): the target names a feature, not a definition, a package or another namespace; an unresolved target is the name-resolution tier's error first, in both tools |
internal/check/passes/w8d_assignment_referent.go:assignmentReferentChecker.check (over symbols.SymbolKind.IsFeature) |
An assignment must have a referent. PD is declared `part def`, not a feature. — the pilot's sentence, followed by what the target is |
semantic/s43-assign-to-non-feature.sysml |
✅ faithful |
validateAssignmentActionUsageReferentIsTimeVarying |
SysML | The referent of an assignment action is time-varying | internal/check/passes/w8d_assignment_referent.go:AssignmentReferentPass.Run | — | semantic/s05-assign-to-package-level-attribute.sysml |
✅ faithful |
validateAttributeDefinitionFeatures |
SysML | Owned features of an attribute definition are non-composite (checkAttributeDefinition, active). Unobservable in text: the pilot's UsageAdapter.postProcess sets isComposite = false on every usage whose expected featuring type is an attribute definition, and feature/composite are syntax errors in SysML. Tried, pilot silent: attribute def A { part p : PD; }, item/action/port/occurrence members, nested part p { part q; }, end/in parts, perform/exhibit/include, constraint/requirement/calc/state/connection/flow members, variation part p { variant part a; }, defaulted parts, a redefining part :>> p in a specializing attribute definition |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateAttributeUsageEnumerationType |
SysML | An attribute typed by an enumeration definition has no other type | internal/check/passes/one_type.go:checkOneType | — | semantic/s06-enum-attribute-two-types.sysml |
✅ faithful |
validateAttributeUsageFeatures |
SysML | Owned features of an attribute usage are non-composite (checkAttributeUsage, active). Unobservable in text for the same reason as validateAttributeDefinitionFeatures: UsageAdapter.postProcess clears isComposite when the expected featuring type is an attribute usage. Tried, pilot silent: attribute a { part p : PD; } in a part definition and at package level, item/action/port/occurrence members, nested parts, end/in parts, ref attribute a { part p; }, typed attribute a : Real { part p; }, a redefining attribute :>> a { part :>> p; part r; } |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateAttributeUsageIsReferential |
SysML | An attribute usage is referential (checkAttributeUsage, active). Unobservable in text: AttributeUsageImpl constructs with isComposite = false, UsageAdapter.postProcess clears it again for attribute featuring, and composite attribute a; is a syntax error. Tried, pilot silent: attribute a;, ref r;, bare x;, valued/typed attributes, end/in attributes, variation attribute v { variant attribute w; }, ordered nonunique and redefined attributes, in/out parameters |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateAttributeUsageType |
SysML | An attribute is typed by attribute definitions | internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | xpect/p15-attribute-typed-by-part-def.sysml |
✅ faithful |
validateCalculationUsageType |
SysML | A calculation is typed by one calculation definition | internal/check/passes/one_type.go:checkOneType | — | semantic/s07-calc-typed-by-action-def.sysml |
✅ faithful |
validateCaseDefinitionOnlyOneObjective |
SysML | A case definition has at most one objective | internal/check/passes/at_most_one_member.go:checkAtMostOneRole | — | semantic/s08-case-def-two-objectives.sysml, semantic/s89-case-def-inherits-two-objectives.sysml |
✅ faithful |
validateCaseDefinitionOnlyOneSubject |
SysML | A case definition has at most one subject | internal/check/passes/at_most_one_member.go:checkAtMostOneMember | — | semantic/s09-case-def-two-subjects.sysml |
✅ faithful |
validateCaseDefinitionSubjectParameterPosition |
SysML | A case definition's subject is its first parameter | internal/check/passes/at_most_one_member.go:checkSubjectParameterPosition | — | semantic/s10-case-def-subject-not-first.sysml |
✅ faithful |
validateCaseUsageOnlyOneObjective |
SysML | A case usage has at most one objective | internal/check/passes/at_most_one_member.go:checkAtMostOneRole | — | semantic/s11-case-two-objectives.sysml, semantic/s91-case-references-second-objective.sysml |
✅ faithful |
validateCaseUsageOnlyOneSubject |
SysML | A case usage has at most one subject | internal/check/passes/at_most_one_member.go:checkAtMostOneMember | — | semantic/s12-case-two-subjects.sysml |
✅ faithful |
validateCaseUsageSubjectParameterPosition |
SysML | A case usage's subject is its first parameter | internal/check/passes/at_most_one_member.go:checkSubjectParameterPosition | — | semantic/s13-case-subject-not-first.sysml |
✅ faithful |
validateCaseUsageType |
SysML | A case is typed by one case definition | internal/check/passes/one_type.go:checkOneType | — | semantic/s14-case-typed-by-action-def.sysml |
✅ faithful |
validateConjugatedPortDefinitionConjugatedPortDefinition |
SysML | A conjugated port definition has no conjugated port definition of its own (checkConjugatedPortDefinition, active). Unobservable in text: SysML.xtext ConjugatedPortDefinitionMember is an implicit member the grammar adds to every port def, no notation declares or nests one, and ~~PD is a syntax error. Tried, pilot silent: port def PD;, port definitions nested in port definitions, port p : ~PD and port def Q :> ~PD forms |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateConnectionUsageType |
SysML | A connection is typed by connection definitions | internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | semantic/s15-connection-typed-by-part-def.sysml |
✅ faithful |
validateControlNodeIncomingSuccessions |
SysML | Incoming successions of a control node have target multiplicity 1; the pinned pilot declares the constraint but its check is a TODO, so it is silent on the textual form (pilot-rejection.md, omg-issues.md) |
internal/check/passes/behavior/control_node.go:ControlNodeSuccessionPass.Run | succession into fork f has target multiplicity [0..1]; successions into a fork node must have target multiplicity [1] |
semantic/cn06-fork-incoming-target-multiplicity.sysml |
✅ faithful |
validateControlNodeOutgoingSuccessions |
SysML | Outgoing successions of a control node have source multiplicity 1; the pinned pilot declares the constraint but its check is a TODO, so it is silent on the textual form (pilot-rejection.md, omg-issues.md) |
internal/check/passes/behavior/control_node.go:ControlNodeSuccessionPass.Run | succession out of join j has source multiplicity [0..1]; successions out of a join node must have source multiplicity [1] |
semantic/cn07-join-outgoing-source-multiplicity.sysml |
✅ faithful |
validateControlNodeOwningType |
SysML | A control node is owned by an action definition or usage (A control node must be owned by an action definition or usage.); the only control-node constraint the pinned pilot checks |
internal/check/passes/behavior/control_node.go:ControlNodeSuccessionPass.Run | fork f is declared in constraint def C, which is not an action; declare it in the body of an action definition or usage |
semantic/cn05-control-node-outside-action.sysml |
✅ faithful |
validateDecisionNodeIncomingSuccessions |
SysML | A decision node has at most one incoming succession; the pinned pilot declares the constraint but its check is a TODO, so it is silent on the textual form (pilot-rejection.md, omg-issues.md) |
internal/check/passes/behavior/control_node.go:ControlNodeSuccessionPass.Run | decide d has 2 incoming successions; a decision node may have at most one — merge the flows before the decision |
semantic/cn04-decide-two-incoming.sysml |
✅ faithful |
validateDecisionNodeOutgoingSuccessions |
SysML | Outgoing successions of a decision node have target multiplicity 0..1; the pinned pilot declares the constraint but its check is a TODO, so it is silent on the textual form (pilot-rejection.md, omg-issues.md) |
internal/check/passes/behavior/control_node.go:ControlNodeSuccessionPass.Run | succession out of decide d has target multiplicity [1]; successions out of a decision node must have target multiplicity [0..1] |
semantic/cn09-decide-outgoing-target-multiplicity.sysml |
✅ faithful |
validateDefinitionVariationIsAbstract |
SysML | A variation definition is abstract (validateDefinitionVariationIsAbstract, constant declared in SysMLValidator, no @Check uses it; DefinitionAdapter.postProcess sets isAbstract on every variation definition). Unobservable in text. Tried, pilot silent on this rule: variation part def V { variant part a; }, a variation definition specialized by a non-variation, a non-variation adding variant part b (validateVariationMembershipOwningNamespace instead), nested variations |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateDefinitionVariationMembership |
SysML | An owned usage of a variation definition is a variant | internal/check/passes/w8d_variability.go:W8DVariabilityPass.Run | — | xpect/p09-variation-member-not-variant.sysml |
✅ faithful |
validateDefinitionVariationSpecialization |
SysML | A variation definition does not specialize another variation | internal/check/passes/w8d_variability.go:W8DVariabilityPass.Run | same wording between two variation definitions; when an enumeration definition is involved the message names the implicit variation and the fix |
semantic/s47-enumeration-specializes-enumeration.sysml |
✅ faithful |
validateEnumerationDefinitionIsVariation |
SysML | An enumeration definition is a variation (checkEnumerationDefinition, active). Unobservable in text: EnumerationDefinitionImpl fixes isVariation = true and variation enum def is a syntax error. Tried, pilot silent on this rule: enum def E;, enum def F { a; b; }, enum def G :> Real { x = 1; }, abstract enum def H, enum def F :> E (validateDefinitionVariationSpecialization instead) |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateEnumerationUsageType |
SysML | An enumeration usage is typed by one enumeration definition | internal/check/passes/one_type.go:checkOneType | — | xpect/p18-enum-two-types.sysml |
✅ faithful |
validateEventOccurrenceUsageIsReference |
SysML | An event occurrence usage is referential (checkEventOccurrenceUsage, active). Unobservable in text: EventOccurrenceUsageImpl constructs with isComposite = false and the event/perform/exhibit/include productions carry no composite prefix. Tried, pilot silent: event occurrence e; in an occurrence definition, a part definition and a package, typed/ref/in/end forms, event a.b, event occurrence g { occurrence h; }, perform/exhibit/include with and without a declaration, variation event occurrence ve { variant event occurrence a; } |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateEventOccurrenceUsageReferent |
SysML | An event occurrence usage references an occurrence | internal/check/passes/w8d_occurrence_typing.go:W8DOccurrenceTypingPass.Run | — | semantic/s16-event-references-non-occurrence.sysml |
✅ faithful |
validateExhibitStateUsageReference |
SysML | An exhibit state usage references a state | internal/check/passes/w11a_usage_typing.go:W11AUsageTypingPass.Run | — | semantic/s17-exhibit-references-non-state.sysml |
✅ faithful |
validateExposeIsImportAll |
SysML | An expose imports all (checkExpose, active). Unobservable in text: MembershipExposeImpl and NamespaceExposeImpl construct with isImportAll = true and the Expose productions have no all keyword (expose all Q::* is a syntax error). Tried, pilot silent: expose Q::*, expose Q::x, expose Q::**, expose Q::*::**, expose Q::* [true], expose in a view definition |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateExposeOwningNamespace |
SysML | Only view usages expose elements. Every owner probed agrees in direction with the pilot — a view usage (plain, typed, nested in a part or a view def, expose D, D::*, D::**, filtered) is silent in both; a part, action, requirement, viewpoint or rendering definition or usage is an error in OpenSysML where the pilot grammar has a syntax error (mismatched input 'expose' expecting '}'), and a package body is a parse error in both. The one deliberate residue is a view def body: a nonstandard-notation warning in OpenSysML ( `expose` in a view def body, the maintainer decision recorded in spec-compliance.md) where the pilot has the same syntax error |
internal/syntax/parser/defusage.go:misplacedMember (syntax tier, so an unrelated syntax error elsewhere no longer hides it); the view def warning is internal/check/passes/nonstandard_notation.go:notationWalker.expose | 'expose' declares what a view usage exposes and is only allowed in a view usage body. Stays approximate: expose in a view definition body is a deliberate extension (warning), see spec-compliance.md. |
grammar/g67-expose-outside-view-body.sysml |
|
validateFlowDefinitionConnectionEnds |
SysML | A flow definition has at most two ends | internal/check/passes/w10b_ends.go:W10BEndKindPass.Run | — | semantic/s18-flow-def-three-ends.sysml |
✅ faithful |
validateFlowUsageType |
SysML | A flow is typed by flow definitions | internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | semantic/s19-flow-typed-by-connection-def.sysml |
✅ faithful |
validateForLoopActionUsageLoopVariable |
SysML | A for loop's first owned feature is a reference usage (A for loop action must have a loop variable.; checkForLoopActionUsage tests that ownedFeature is non-empty and its first element is a ReferenceUsage). Grammar-unconstructable: ForLoopNode parses 'for' ForVariableDeclarationMember 'in' … first, ForVariableDeclaration returns SysML::ReferenceUsage, and ActionNodePrefix admits no owned feature ahead of it. Tried for i in seq {}, for i : Integer in seq {}, for i :>> n in seq {}, nested loops, for i in seq action b { in extra : Integer; }, for x in seq { action y :>> x; }, and the variable-less spellings for in seq {}, for in i in seq {}, for i in {}, for i in seq;: never reported; the variable-less spellings are syntax errors in both tools (pilot no viable alternative at input 'for', OpenSysML expected variable name after 'for') |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateForLoopActionUsageParameters |
SysML | A for loop has exactly two input parameters (A for loop action must have two parameters.; checkForLoopActionUsage tests inputParameters.size != 2). Grammar-unconstructable: ForLoopNode parses exactly one NodeParameterMember (the sequence) and one ActionBodyParameterMember (the body), both ParameterMemberships whose parameters ParameterMembershipAdapter.postProcess sets to direction in; the loop variable's ForVariableDeclarationMember is a plain FeatureMembership with no direction, and the node has no body of its own in which a further directed feature could be declared (for i in seq { in extra : Integer; } declares extra in the body action). Tried the shapes listed under validateForLoopActionUsageLoopVariable plus for i in seq action b { out o : Integer; } and two loops in sequence: never reported; OpenSysML has no count check either, its parser requires the same two parts |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateForkNodeIncomingSuccessions |
SysML | A fork node has at most one incoming succession; the pinned pilot declares the constraint but its check is a TODO, so it is silent on the textual form (pilot-rejection.md, omg-issues.md) |
internal/check/passes/behavior/control_node.go:ControlNodeSuccessionPass.Run | fork f has 2 incoming successions; a fork node may have at most one — merge or join the flows before the fork |
semantic/cn01-fork-two-incoming.sysml |
✅ faithful |
validateFramedConcernMembershipConstraintKind |
SysML | A framed concern membership has kind requirement (checkFramedConcernMembership, active). Unobservable in text: SysML.xtext FramedConcernKind has the single literal frame, so no other kind can be written; require concern, assume concern, frame assume concern and frame outside a requirement body are syntax errors. Tried, pilot silent: frame concern c;, typed, bare frame d;, with a body, redefining frame concern :>> c and frame :>> c |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateIfActionUsageParameters |
SysML | An if action has at least two input parameters (An if action must have at least two parameters.; checkIfActionUsage tests inputParameters.size < 2). Grammar-unconstructable: IfNode always parses an ExpressionParameterMember and an ActionBodyParameterMember (a third with else), each a ParameterMembership whose parameter ParameterMembershipAdapter.postProcess sets to direction in. Tried if c {}, if c {} else {}, else if chains, if n {} (a non-Boolean condition), if c action b { in extra : Integer; }, action i : Q if c {}, and the truncated spellings if {}, if c;, if c else {}, if c {} else;: never reported; the truncated spellings are syntax errors in both tools (pilot no viable alternative at input 'if', OpenSysML expected '{' after if condition / expected '{' after else) |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateIncludeUseCaseUsageReference |
SysML | An include use case usage references a use case | internal/check/passes/w11a_usage_typing.go:W11AUsageTypingPass.Run | — | semantic/s20-include-references-non-use-case.sysml |
✅ faithful |
validateInterfaceDefinitionEnd |
SysML | An interface definition's ends are ports | internal/check/passes/w10b_ends.go:W10BEndKindPass.Run | — | semantic/s21-interface-def-end-not-port.sysml |
✅ faithful |
validateInterfaceUsageEnd |
SysML | An interface usage's ends are ports | internal/check/passes/w10b_ends.go:W10BEndKindPass.Run | — | xpect/p27-interface-end-not-port.sysml |
✅ faithful |
validateInterfaceUsageType |
SysML | An interface is typed by interface definitions | internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | semantic/s22-interface-typed-by-connection-def.sysml |
✅ faithful |
validateItemUsageType |
SysML | An item is typed by item definitions (An item must be typed by item definitions.; constant validateItemUsageType_ declared in SysMLValidator, checkItemUsage commented out). Unobservable: the pilot reports validateOccurrenceUsageType_ instead. Tried: item i : AD (action def), : DT (attribute def), : Real, : Anything, : Occurrence, : POD (port def), a redefining item :>> i |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateJoinNodeOutgoingSuccessions |
SysML | A join node has at most one outgoing succession; the pinned pilot declares the constraint but its check is a TODO, so it is silent on the textual form (pilot-rejection.md, omg-issues.md) |
internal/check/passes/behavior/control_node.go:ControlNodeSuccessionPass.Run | join j has 2 outgoing successions; a join node may have at most one — follow the join with a fork or decision node to branch |
semantic/cn02-join-two-outgoing.sysml |
✅ faithful |
validateMergeNodeIncomingSuccessions |
SysML | Incoming successions of a merge node have source multiplicity 0..1; the pinned pilot declares the constraint but its check is a TODO, so it is silent on the textual form (pilot-rejection.md, omg-issues.md) |
internal/check/passes/behavior/control_node.go:ControlNodeSuccessionPass.Run | succession into merge m has source multiplicity [1]; successions into a merge node must have source multiplicity [0..1] |
semantic/cn08-merge-incoming-source-multiplicity.sysml |
✅ faithful |
validateMergeNodeOutgoingSuccessions |
SysML | A merge node has at most one outgoing succession; the pinned pilot declares the constraint but its check is a TODO, so it is silent on the textual form (pilot-rejection.md, omg-issues.md) |
internal/check/passes/behavior/control_node.go:ControlNodeSuccessionPass.Run | merge m has 2 outgoing successions; a merge node may have at most one — follow the merge with a fork or decision node to branch |
semantic/cn03-merge-two-outgoing.sysml |
✅ faithful |
validateMetadataUsageType |
SysML | A metadata usage is typed by exactly one metadata definition or metaclass (A metadata usage must be typed by one metadata definition.); a part definition or a second type is rejected, an abstract one by validateMetadataFeatureMetadataNotAbstract |
internal/check/passes/w8c_metadata_type.go:MetadataTypePass.Run | — | semantic/s23-metadata-typed-by-part-def.sysml |
✅ faithful |
validateObjectiveMembershipIsComposite |
SysML | An objective is composite (checkObjectiveMembership, active). Unobservable in text: ObjectiveRequirementUsage admits no ref, direction or end prefix (ref objective and objective #meta are syntax errors) and UsageAdapter.postProcess keeps a usage owned by a case composite. Tried, pilot silent: objective o;, typed, anonymous with a body, objective :>> o, an objective in a variant use case |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateObjectiveMembershipOwningType |
SysML | Only cases have objectives; the pilot grammar rejects objective elsewhere (mismatched input 'objective' expecting '}') |
internal/syntax/parser/defusage.go:Parser.misplacedMember (syntax tier, like the pilot) | 'objective' declares the objective of a case and is only allowed in a case body; move it into the case it belongs to |
grammar/g63-objective-outside-case-body.sysml |
✅ faithful |
validateOccurrenceUsageIndividualDefinition |
SysML | An occurrence usage is typed by at most one individual definition | internal/check/passes/w10b_individual_portion.go:W10BIndividualTypingPass.Run | — | xpect/p25-two-individual-definitions.sysml |
✅ faithful |
validateOccurrenceUsageIndividualUsage |
SysML | An individual usage is typed by one individual definition | internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | xpect/p33-individual-typed-by-plain-def.sysml |
✅ faithful |
validateOccurrenceUsageIsPortion |
SysML | A portion usage is owned by an occurrence definition or usage | internal/check/passes/w10b_individual_portion.go:W10BPortionOwnerPass.Run | — | semantic/s45-snapshot-outside-occurrence.sysml |
✅ faithful |
validateOccurrenceUsageType |
SysML | An occurrence, item or part is typed by occurrence definitions | internal/check/passes/w8d_occurrence_typing.go:W8DOccurrenceTypingPass.Run | — | xpect/p16-part-typed-by-attribute-def.sysml |
✅ faithful |
validateOperatorExpressionQuantity |
SysML | The right operand of [ on a quantity is a measurement reference (warning Should be a measurement reference (unit).) |
internal/check/passes/typecheck_expr.go:exprChecker.checkBracket; internal/semantic/semantics/operator_conformance.go:Model.UnitOperandConformance | the unit of a quantity must be a measurement reference, found Natural: write a unit such as `` [m] `` or name a feature typed by MeasurementUnit or another measurement reference — at the unit operand; as the pilot, an operator expression over units (m * s, m * 2, (m, 3)) whose declared result is wider than TensorMeasurementReference conforms when an operand it is passed by value does; a conditional's branches and the fallback of ?? are expression bodies, so if c ? m else s warns; seq#(i) is judged by seq alone (the pilot accepts either argument of #); a quantity value nested as the unit (10 [2 [m]]) warns, where the pilot's recursion accepts it for the m — see omg-issues.md |
none | ✅ faithful |
validatePartUsagePartDefinition |
SysML | A part is typed by at least one part definition (A part must be typed by at least one part definition.; constant declared in SysMLValidator, checkPartUsage commented out). Unobservable: no @Check reports it. Tried, pilot silent: part p1 : ID (item def only), part p2;, part p3 : ID, PD, part p4 :> p1, part p5 : Occurrence, part p6 : Anything, part p9 : Item, redefining part :>> p typed by an item definition |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validatePartUsageType |
SysML | A part is typed by item definitions (A part must be typed by item definitions.; constant validatePartUsageType_ declared in SysMLValidator, checkPartUsage commented out). Unobservable: the pilot reports validateOccurrenceUsageType_ instead. Tried: part p7 : AD (action def), part p8 : Real, part p : POD (port def), part p6 : Anything |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validatePerformActionUsageReference |
SysML | A perform action usage references an action | internal/check/passes/w11a_usage_typing.go:W11AUsageTypingPass.Run | — | semantic/s24-perform-references-non-action.sysml |
✅ faithful |
validatePortDefinitionConjugatedPortDefinition |
SysML | A port definition has exactly one conjugated port definition (checkPortDefinition, active). Unobservable in text: SysML.xtext PortDefinition always adds one ConjugatedPortDefinitionMember and no notation adds or removes one. Tried, pilot silent: port def PD;, nested port definitions, port def Q :> ~PD, port p : ~PD |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validatePortDefinitionOwnedUsagesNotComposite |
SysML | Owned usages of a port definition other than ports are referential | internal/check/passes/w10b_structural.go:W10BStructuralPass.Run | — | xpect/p26-port-def-nonreferential-usage.sysml |
✅ faithful |
validatePortUsageIsReference |
SysML | A port usage whose owning type is not a port definition or port usage must be referential (A port usage must be referential.). Observable only on a variant: PortUsageAdapter.postProcess clears isComposite for every other owner, but a variant port a : PD; under a variation port owned by a port definition or port usage keeps it, and the variant has no owning type |
internal/check/passes/w10b_structural.go:W10BStructuralPass.Run | — | semantic/s52-variant-port-composite.sysml |
✅ faithful |
validatePortUsageNestedUsagesNotComposite |
SysML | Nested usages of a port usage other than ports are referential | internal/check/passes/w10b_structural.go:W10BStructuralPass.Run | — | semantic/s25-port-nested-composite-part.sysml |
✅ faithful |
validatePortUsageType |
SysML | A port is typed by port definitions | internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | semantic/s26-port-typed-by-part-def.sysml |
✅ faithful |
validateReferenceUsageIsReference |
SysML | A reference usage is referential (checkReferenceUsage, active). Unobservable in text: ReferenceUsageImpl constructs with isComposite = false and every production yielding one (ref x;, bare x;, variant x;, end/directed usages) is referential by grammar. Tried, pilot silent: ref r;, bare x;, ref part rp;, inout ref w;, variant p1; |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateRenderingUsageType |
SysML | A rendering is typed by one rendering definition | internal/check/passes/one_type.go:checkOneType | — | semantic/s27-rendering-typed-by-part-def.sysml |
✅ faithful |
validateRequirementConstraintMembershipIsComposite |
SysML | A required or assumed constraint is composite (checkRequirementConstraintMembership, active). Unobservable in text: RequirementConstraintUsage admits no ref, direction or end prefix (require ref constraint and require #meta constraint are syntax errors; require outside a requirement body too) and UsageAdapter.postProcess keeps a usage owned by a requirement composite. Tried, pilot silent: require constraint c;, assume constraint d : CD;, bare require c;, anonymous require constraint { true }, require constraint :>> c, a required constraint in a variant requirement |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateRequirementConstraintMembershipOwningType |
SysML | Only requirements have assumed or required constraints. Every owner probed agrees in direction with the pilot: a requirement, concern or viewpoint definition or usage, a satisfy requirement … { } body and an objective body are silent in both, whether the member is require/assume constraint k : K, an inline require constraint { … } or a reference require k; a package, part, action, constraint, case, analysis or verification definition or usage is reported by OpenSysML where the pilot grammar has a syntax error (mismatched input 'require' expecting '}'). The residue is layer and severity: a warning by default and an error under -strict, because the placement is a documented OpenSysML extension |
internal/check/passes/nonstandard_notation.go:NonstandardNotationPass.Run (syntax tier) | warning `require` outside a requirement body is an OpenSysML extension with no SysML v2 production (error under -strict). Stays approximate: a deliberate extension — warning by default, an error under -strict, which matches the pilot. |
extensions/x08-require-outside-requirement-body.sysml |
|
validateRequirementDefinitionOnlyOneSubject |
SysML | A requirement definition has at most one subject | internal/check/passes/at_most_one_member.go:checkAtMostOneMember | — | xpect/p14-requirement-two-subjects.sysml, semantic/s90-requirement-def-inherits-two-subjects.sysml |
✅ faithful |
validateRequirementDefinitionSubjectParameterPosition |
SysML | A requirement definition's subject is its first parameter | internal/check/passes/at_most_one_member.go:checkSubjectParameterPosition | — | semantic/s28-requirement-def-subject-not-first.sysml |
✅ faithful |
validateRequirementUsageOnlyOneSubject |
SysML | A requirement usage has at most one subject | internal/check/passes/at_most_one_member.go:checkAtMostOneMember | — | semantic/s29-requirement-two-subjects.sysml, semantic/s92-requirement-references-second-subject.sysml |
✅ faithful |
validateRequirementUsageSubjectParameterPosition |
SysML | A requirement usage's subject is its first parameter | internal/check/passes/at_most_one_member.go:checkSubjectParameterPosition | — | semantic/s30-requirement-subject-not-first.sysml |
✅ faithful |
validateRequirementUsageType |
SysML | A requirement is typed by one requirement definition | internal/check/passes/one_type.go:checkOneType | — | semantic/s31-requirement-typed-by-constraint-def.sysml |
✅ faithful |
validateRequirementVerificationMembershipKind |
SysML | A requirement verification membership has kind requirement (checkRequirementVerificationMembership, active). Unobservable in text: SysML.xtext RequirementVerificationKind has the single literal verify; verify assume requirement and verify outside an objective are syntax errors. Tried, pilot silent: verify requirement r;, typed, bare verify r;, anonymous with a body, verify requirement :>> r |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateRequirementVerificationMembershipOwningType |
SysML | A requirement verification is in the objective of a verification case | internal/check/passes/w8d_verification.go:W8DVerificationPass.Run | — | xpect/p29-verify-outside-objective.sysml |
✅ faithful |
validateSatisfyRequirementUsageReference |
SysML | A satisfy requirement usage references a requirement (Must reference a requirement.): satisfy r, satisfy r by x, satisfy requirement s : RD (no reference, silent) and a feature chain (its last feature decides), the referent a direct, inherited, redefined, aliased or nested requirement usage, an objective, a concern or viewpoint usage, stated in a part, requirement, action or case body alike; a constraint, part, attribute, item, action or a requirement definition is reported, as it is in the pilot |
internal/check/passes/typecheck.go:referentKindMessage (chains through internal/check/passes/typecheck.go:typeChecker.checkChainReferenceKind; the kinds admitted by internal/check/passes/typecheck.go:isRequirementUsageKind) | satisfy target must be a requirement usage, found partUsage |
semantic/s32-satisfy-references-non-requirement.sysml |
✅ faithful |
validateSendActionUsagePayloadArgument |
SysML | A send action used as a state entry/do/exit subaction or transition effect has a payload argument (A send action must have a payload.; the pilot grammar already demands the payload there, while send to x inside an action body is accepted by both tools) |
internal/check/passes/send_action.go:SendActionPass.Run | a send action written as a state subaction or a transition effect must have a payload: name the message it sends, as in \send new Msg() to receiver`` |
semantic/send-subaction-no-payload.sysml |
✅ faithful |
validateSendActionUsageReceiver |
SysML | Sending to a port should use via rather than to (warning Sending to a port should generally use "via" instead of "to".) |
internal/check/passes/send_action.go:SendActionPass.Run | warning sending to the port p should use 'via' rather than 'to': 'via' routes the message through a port of the sender, while 'to' names the receiver; a to/via argument typed by a non-occurrence is additionally a warning, where the pilot reports its generic Bound features should have conforming types |
none | ✅ faithful |
validateStakeholderMembershipOwningType |
SysML | Only requirements have stakeholders; the pilot grammar rejects stakeholder elsewhere (mismatched input 'stakeholder' expecting '}') |
internal/syntax/parser/defusage.go:Parser.misplacedMember (syntax tier, like the pilot) | 'stakeholder' declares a stakeholder of a requirement and is only allowed in a requirement body; move it into the requirement it belongs to |
grammar/g64-stakeholder-outside-requirement-body.sysml |
✅ faithful |
validateStateDefinitionParallelSubactions |
SysML | A parallel state definition has no successions or transitions | internal/check/passes/behavior/state_transition.go:transitionChecker.checkParallelStates | — | xpect/p19-parallel-state-with-transition.sysml |
✅ faithful |
validateStateDefinitionSubactionKind |
SysML | A state definition has at most one entry, do and exit action each | internal/check/passes/w10b_structural.go:W10BStructuralPass.Run | — | xpect/p13-state-two-entry-actions.sysml |
✅ faithful |
validateStateSubactionMembershioOwningType |
SysML | Only a state has entry, do or exit actions (the pilot's constant is spelled Membershio); the pilot grammar rejects them elsewhere (mismatched input 'entry' expecting '}') |
internal/syntax/parser/defusage.go:Parser.misplacedMember (syntax tier, like the pilot) | 'entry' declares the entry action of a state and is only allowed in a state body; move it into the state it belongs to (likewise for do and exit) |
grammar/g07-entry-outside-state-body.sysml, grammar/g08-do-outside-state-body.sysml, grammar/g65-entry-action-outside-state-body.sysml |
✅ faithful |
validateStateUsageParallelSubactions |
SysML | A parallel state usage has no successions or transitions | internal/check/passes/behavior/state_transition.go:transitionChecker.checkParallelStates | — | semantic/s33-parallel-state-usage-with-succession.sysml |
✅ faithful |
validateStateUsageSubactionKind |
SysML | A state usage has at most one entry, do and exit action each | internal/check/passes/w10b_structural.go:W10BStructuralPass.Run | — | semantic/s34-state-usage-two-entry-actions.sysml |
✅ faithful |
validateStateUsageType |
SysML | A state is typed by state definitions | internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | semantic/s35-state-typed-by-part-def.sysml |
✅ faithful |
validateSubjectMembershipOwningType |
SysML | Only requirements and cases have subjects; the pilot grammar rejects subject elsewhere (mismatched input 'subject' expecting '}') |
internal/syntax/parser/defusage.go:Parser.misplacedMember (syntax tier, like the pilot) | 'subject' declares the subject of a requirement or case and is only allowed in a requirement or case body; move it into the requirement or case it belongs to |
grammar/g62-subject-outside-requirement-body.sysml |
✅ faithful |
validateTransitionFeatureMembershipEffectAction |
SysML | The feature of an effect (do) transition feature membership is an action usage (Must be an action.; checkTransitionFeatureMembership tests !(mem.transitionFeature instanceof ActionUsage)). Grammar-unconstructable: EffectBehaviorMember is the only production of a kind = effect membership and its EffectBehaviorUsage returns SysML::ActionUsage (an empty action or a perform, accept, send or assign node). Tried do act, do q (a part), do act.q, do send Sig() to q, do assign c := true, do action x : Q, do perform q, do accept Sig, in transition first s1 … then s2 and after a state (state s3; transition do act then s2;): the pilot reports validatePerformActionUsageReference (Must reference an action.) and validateActionUsageType on a non-action referent, or a syntax error, never this constraint |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateTransitionFeatureMembershipGuardExpression |
SysML | A transition guard is a Boolean expression, in every spelling that is a TransitionUsage: transition first a if g then b, accept … if g then b, if g then b and transition if g then b in a state body, and the guarded successions of an action body (first a if g then b, succession s first a if g then b, a decision's if g then b). A String, Natural, Rational, enumeration or part-typed guard, a non-Boolean calc or chain is reported; a Boolean literal, attribute, Boolean-specialising attribute, [0..1] attribute, untyped attribute, null, Boolean operator expression, constraint reference, Boolean calc or chain is silent. The pinned pilot reports none of these with the standard library loaded: its ExpressionAdapter makes every guard redefine TransitionPerformance::guard (bool guard[*]), whose result is Boolean, so its isBoolean test is vacuous — its own TransitionUsage_invalid.sysml.xt expects the error, so the check is adjudicated for the specification (omg-issues.md). The OCL's second clause, that the guard's result multiplicity is 1..1, is checked by neither tool (if flags with flags : Boolean[*] is silent in both); the corpus case is ours-only by the pilot gap above |
internal/check/passes/transition_guard.go:TransitionGuardPass.Run (every guard-carrying node) through internal/check/passes/typecheck_expr.go:exprChecker.checkBoolean | transition guard must be Boolean, found String |
semantic/s81-guarded-succession-guard-not-boolean.sysml |
✅ faithful |
validateTransitionFeatureMembershipOwningType |
SysML | A transition feature membership is owned by a transition usage (Transition feature membership not allowed.; checkTransitionFeatureMembership tests !(mem.owningType instanceof TransitionUsage)). Grammar-unconstructable: TransitionFeatureMembership is produced only by TriggerActionMember, GuardExpressionMember and EffectBehaviorMember, which occur only in TransitionUsage, TargetTransitionUsage, GuardedSuccession and GuardedTargetSuccession, all of which return SysML::TransitionUsage; KerML has no such membership, and no keyword-first, feature or body spelling reaches those productions from another owner. Tried accept/if/do clauses on transition first … then, the action-body forms first a1 if c then a2;, action a3; if c then a2;, action a3; then a2; and decide d; if c then a2; else a1;, the state-body forms state s3; accept Sig then s2;, state s3; if c then s2;, state s3; then s1;, state s3; transition do act then s2; and entry; if c then s1;, and the clauses written where no transition production applies (state s3 { accept Sig then s2; }, state s3; do act then s2;, action a3; accept Sig then a2;, action a3 { if c then a2; }), which the pilot rejects as syntax errors: never reported |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateTransitionFeatureMembershipTriggerAction |
SysML | The feature of a trigger (accept) transition feature membership is an accept action usage (Must be an accept action.; checkTransitionFeatureMembership tests !(mem.transitionFeature instanceof AcceptActionUsage)). Grammar-unconstructable: TriggerActionMember is the only production of a kind = trigger membership and its TriggerAction returns SysML::AcceptActionUsage. Tried accept Sig, accept x : Sig, accept after 5 [s], accept :>> q, accept x : Q, accept q and accept act (a part or action usage as the payload type, which the pilot reports as validateUsageType: A usage must be typed by definitions.), with guards and effects, on transition first s1 … then s2 and state s3; accept … then s2;, and the payload-less accept then s2 / transition first s3 accept then s2 (syntax errors in both tools): never reported |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateTransitionUsageParameters |
SysML | A transition usage has at least one input parameter, at least two when it has a trigger (Must have an input parameter. / Must have two input parameters.; checkTransitionUsage tests inputParameters.size < 1, or < 2 when triggerAction is non-empty). Grammar-unconstructable: every production returning TransitionUsage parses an EmptyParameterMember first and a second one together with its TriggerActionMember, each a ParameterMembership whose parameter ParameterMembershipAdapter.postProcess sets to direction in, and triggerAction is derived from that same membership. Tried transition first s1 then s2 alone and with accept, if, do and all three, transition t : Q first s1 then s2 (reported as validateActionUsageType), then s2 / accept Sig then s2 / if c then s2 / transition do act then s2 after a state, entry; then s1;, the action-body forms first a1 then a2;, first a1 if c then a2;, action a3; if c then a2;, action a3; then a2; and decide d; if c then a2; else a1;, bodies { in extra : Integer; } and { :>> payload : Sig; }, and the clause-less transition first s3 accept then s2 / … if then s2 (syntax errors in both tools): never reported; OpenSysML has no parameter-count check, its parser requires the same clauses |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateTransitionUsageSuccession |
SysML | A transition owns a succession whose targets are action usages (A transition must own a succession to its target.); a transition without a succession is a syntax error in both tools. A target that is a part, item, port, attribute, constraint usage, a chain ending in one, or a state definition is reported by both; a state usage, an exhibit state and a chain to a nested state are silent in both. The residue is OpenSysML's state-machine reading, stricter than the pilot's OCL: a target that is a plain action, calc or perform usage, an entry/do subaction or a chain ending in an action of a nested state (then s2.a) passes the pilot (each is an ActionUsage) and is reported here, as is an action named as the source, which the pilot does not check at all |
internal/semantic/resolve/transition.go:Resolver.ResolveEndpoint (name-resolution tier) | transition endpoint p is not a state or pseudostate. Stays approximate: the state-machine reading (a transition targets a state or pseudostate) is what the state executor runs; accepting every action usage as the pilot's OCL does would move the failure from resolution to runtime. |
semantic/s44-transition-target-not-action.sysml |
|
validateTransitionUsageTriggerActions |
SysML | A transition with an accepter has a state as its source | internal/check/passes/behavior/state_transition.go:transitionChecker.checkAccepterSource | — | xpect/p34-accepter-source-not-state.sysml |
✅ faithful |
validateTriggerInvocationActionAfterArgument |
SysML | An after trigger argument is a DurationValue |
internal/check/passes/typecheck_trigger.go:exprChecker.checkTimeEvent | names the found type and the fix (an 'after' trigger's delay must be a DurationValue, found Natural: write it with a duration unit ...) |
semantic/s48-after-trigger-not-duration.sysml |
✅ faithful |
validateTriggerInvocationActionAtArgument |
SysML | An at trigger argument is a TimeInstantValue |
internal/check/passes/typecheck_trigger.go:exprChecker.checkTimeEvent | names the found type and the fix (an 'at' trigger's time must be a TimeInstantValue, found DurationValue: name a feature typed by TimeInstantValue ...) |
semantic/s49-at-trigger-not-time-instant.sysml |
✅ faithful |
validateTriggerInvocationActionWhenArgument |
SysML | A when trigger argument is Boolean |
internal/check/passes/typecheck_trigger.go:triggerArgumentChecker.check | names the found type and the fix (a 'when' trigger's condition must be Boolean, found Integer: compare the value ...) |
semantic/s50-when-trigger-not-boolean.sysml |
✅ faithful |
validateUsageIsReferential |
SysML | A usage that is directed, an end or has no featuring type is referential (checkUsage, active). Unobservable in text: UsageAdapter.postProcess clears isComposite in exactly those cases (getExpectedFeaturingTypeOf follows a variant to its variation's owner), and featured by is not SysML. Tried, pilot silent on this rule: package-level part/item/action/occurrence/port, in/out/inout/end parts and items in part and action definitions, connection ends, package-level and nested variations and variants, in part :>> p, return/subject/actor/stakeholder parts |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateUsageType |
SysML | A usage is typed by definitions (A usage must be typed by definitions.); the pilot reports this general constraint, not the kind-specific one, when a usage of no specific kind is typed by a feature |
internal/check/passes/typecheck.go:compatibleTyping (messages in internal/check/passes/w10b_usage_typing.go:pilotTypingMessage) | — | semantic/s36-usage-typed-by-feature.sysml |
✅ faithful |
validateUsageVariationIsAbstract |
SysML | A variation usage is abstract (checkUsage, active). Unobservable in text: UsageAdapter.postProcess sets isAbstract on every variation usage. Tried, pilot silent on this rule: variation part v { variant part a; } at package level and in a part definition, a redefining part :>> v { } of a variation, nested variations, variation attribute, variation event occurrence, variation port |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateUsageVariationMembership |
SysML | An owned usage of a variation usage is a variant | internal/check/passes/w8d_variability.go:W8DVariabilityPass.Run | — | semantic/s37-variation-usage-member-not-variant.sysml |
✅ faithful |
validateUsageVariationSpecialization |
SysML | A variation usage does not specialize another variation | internal/check/passes/w8d_variability.go:W8DVariabilityPass.Run | — | none | ✅ faithful |
validateUseCaseUsageReference |
SysML | A use case usage that references another references a use case (Must reference a use case.; constant declared in SysMLValidator, no @Check uses it — checkIncludeUseCaseUsage reports validateIncludeUseCaseUsageReference on the same message). Unobservable. Tried: include p; (part) reports validateIncludeUseCaseUsageReference; use case v :> p, use case u :> p, use case w : PD, use case x :>> p report only validateUseCaseUsageType_ |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
validateUseCaseUsageType |
SysML | A use case is typed by one use case definition | internal/check/passes/one_type.go:checkOneType | — | semantic/s38-use-case-typed-by-case-def.sysml |
✅ faithful |
validateVariationMembershipOwningNamespace |
SysML | A variant is an owned member of a variation | internal/check/passes/w8d_variability.go:W8DVariabilityPass.Run | — | xpect/p08-variant-outside-variation.sysml |
✅ faithful |
validateVerificationCaseUsageType |
SysML | A verification case is typed by one verification case definition | internal/check/passes/one_type.go:checkOneType | — | semantic/s39-verification-typed-by-case-def.sysml |
✅ faithful |
validateViewDefinitionOnlyOnvViewRendering |
SysML | A view definition has at most one view rendering (the pilot's constant is spelled Onv) |
internal/check/passes/diagram/view_rendering.go:ViewRenderingPass.Run | — | semantic/s40-view-def-two-renderings.sysml |
✅ faithful |
validateViewRenderingMembershipOwningType |
SysML | Only views have view renderings; the pilot grammar rejects render elsewhere (mismatched input 'render' expecting '}') |
internal/syntax/parser/defusage.go:Parser.misplacedMember (syntax tier, like the pilot) | 'render' declares the rendering of a view and is only allowed in a view body; move it into the view it belongs to |
grammar/g66-render-outside-view-body.sysml |
✅ faithful |
validateViewUsageOnlyOneRendering |
SysML | A view usage has at most one view rendering | internal/check/passes/diagram/view_rendering.go:ViewRenderingPass.Run | — | xpect/p30-two-view-renderings.sysml |
✅ faithful |
validateViewUsageType |
SysML | A view is typed by one view definition | internal/check/passes/one_type.go:checkOneType | — | semantic/s41-view-typed-by-part-def.sysml |
✅ faithful |
validateViewpointUsageType |
SysML | A viewpoint is typed by one viewpoint definition | internal/check/passes/one_type.go:checkOneType | — | semantic/s42-viewpoint-typed-by-requirement-def.sysml |
✅ faithful |
validateWhileLoopActionUsageParameters |
SysML | A while loop has at least two input parameters (A while loop action must have at least two parameters.; checkWhileLoopActionUsage tests inputParameters.size < 2). Grammar-unconstructable: WhileLoopNode always parses an ExpressionParameterMember (while) or an EmptyParameterMember (loop) and an ActionBodyParameterMember (a third with until), each a ParameterMembership whose parameter ParameterMembershipAdapter.postProcess sets to direction in. Tried while c {}, loop {}, loop {} until c;, while c action b { in extra : Integer; }, action w : Q while c {}, and the truncated spellings while {}, while c;, loop;, loop {} until;, while c {} until;: never reported; the truncated spellings are syntax errors in both tools (pilot no viable alternative at input 'while' / 'loop', OpenSysML expected '{' after while condition / expected an expression) |
— | — | none | ❔ unknown — no case and no identifiable pass yet |
Rows are recorded as main stands at the recording date. When a pass lands for a constraint
recorded ❌ or ❔, the row's status moves and -update is not needed — the baseline's statuses
are edited by hand, the names are not. The feature-chain value bindings of
validateBindingConnectorTypeConformance landed on main before this recording, so its row
already describes them.