2023-10 - SysML v2 Pilot Implementation

This is an incremental update to the 2023-08 release. It corresponds to Eclipse plugin version 0.36.0. (There was no 2023-09 release.)

Language Features

1. New KerML validation constraints. Checks have been implemented for the following new constraints, applying to both KerML and SysML:

   • validateRedefinitionDirectionConformance – If the redefinedFeature of a Redefinition has direction in or out, then the redefiningFeature must have the same direction. If the redefinedFeature has direction inout, then the redefiningFeature must have a non-null direction.
   • validateExpressionResultExpressionMembership – An Expression must have at most one ResultExpressionMembership.
   • validateFunctionResultExpressionMembership – A Function must have at most one ResultExpressionMembership.
   • validateFeatureValueOverriding – All Features directly or indirectly redefined by the featureWithValue of a FeatureValue must have only default FeatureValues.

   [PR #504]

2. New SysML validation constraints. Checks have been implemented for the following new constraints, applying only to SysML:

   • validateAssignmentActionUsageArguments – An AssignmentActionUsage must have two argument Expressions.
   • validateAssignmentActionUsageReferent – An AssignmentActionUsage must have an ownedMembership that is not an OwningMembership and whose memberElement is a Feature.
   • validateForLoopActionUsageLoopVariable – The first ownedFeature of a ForLoopActionUsage must be a ReferenceUsage.
   • validateForLoopActionUsageParameters – A ForLoopActionUsage must have two owned input parameters.
   • validateIfActionUsageParameters – An IfActionUsage must have at least two owned input parameters.
   • validateWhileLoopActionUsage – A WhileLoopActionUsage must have at least two owned input parameters.
   • validateTriggerInvocationExpressionAfterArgument – If a TriggerInvocationExpression has kind = after, then it must have an argument Expression with a result that conforms to the type ISQ::DurationValue.
   • validateTriggerInvocationExpressionAtArgument – If a TriggerInvocationExpression has kind = at, then it must have an argument Expression with a result that conforms to the type Time::TimeInstantValue.
   • validateTriggerInvocationExpressionWhenArgument – If a TriggerInvocationExpression has kind = when, then it must have an argument Expression with a result that conforms to the type ScalarValues::Boolean.
   • validateAssertConstraintUsageReference – If an AssertConstraintUsage has an ownedReferenceSubsetting, then its referencedFeature must be a ConstraintUsage.
   • validateSatisfyRequirementUsageReference – If a SatisfyRequirementUsage has an ownedReferenceSubsetting, then its referencedFeature must be a RequirementUsage.

   [PR #506]

3. Feature values on connections. The textual notation now supports declaring connection usages and interface usages with feature values:
   abstract connectionc1;
   abstract connectionc2 = c1; // Previously did not parse.
connectionc3 = c1connecta to b; // Previously did not parse.

   [PR #505]

4. View renderings. The notation for a view rendering usage has been extended to allow the rendering to be defined locally within the containing view, rather than just allowing rendering by reference.

   render renderingname : Def [m] ... ;

   The previous notation renderr; then effectively becomes a shorthand for render rendering referencesr;.

   [PR #505]

Model Libraries

Various library models have been updated to correct violations of new KerML validation constraints, as reported in the following KerML and SysML v2 FTF issues. Note, however, that the resolutions of these issues have not yet been approved by the FTFs and, therefore, are subject to change.
[PR #504]

KerML Issues

• KERML-182 Update Kernel Semantic Library for validateRedefinitionDirectionConformance
• KERML-184 Update Kernel Model Libraries for validateFeatureValueOverriding constraint
• KERML-186 Update semantic model of invariants for validateExpressionResultExpressionMembership constraint

SysML v2 Issues

• SYSML2-491 KerML constraint requires updates to Systems Library models
• SYSML2-492 KerML constraint requires updates to Domain Library models

Backward Incompatibilities

1. Validation constraints. The newly implemented validation constraints (particularly validateRedefinitionDirectionConformance and validateFeatureValueOverriding) may cause some models that previously passed validation to now fail.

Jupyter

None.

Visualization

1. PlantUML
   None.

2. Tom Sawyer
   None.

Technical Updates

None.

Bug Fixes

Bugs reported in the following KerML and SysML v2 issues have been fixed (or mitigated) in this release. Note, however, that the resolutions to these issues have not yet been approved by the FTFs and, therefore, are subject to change.

KerML Issue

• KERML-154 Directed features inherited from a conjugated type not handled properly

[PR #504]

SysML v2 Issues

• SYSML2-495 Textual notation BNF for TriggerExpression is wrong
• SYSML2-497 validateTriggerInvocationExpressionAfterArgument constraint is too strong
• SYSML2-498 validateTriggerInvocationExpressionWhenArgument constraint is wrong
• SYSML2-499 Assignments parsed without a target will fail validateAssignmentActionUsageArguments
• SYSML2-500 The derivation of AssignmentActionUsage::referent is wrong

[PR #506]

2023-08 - SysML v2 Pilot Implementation

This is an incremental update to the 2023-07 release. It corresponds to Eclipse plugin version 0.35.0.

Language Features

None.

Model Libraries

None.

Backward Incompatibilities

None.

Jupyter

None.

Visualization

1. PlantUML
   None.

2. Tom Sawyer
   None.

Technical Updates

None.

Bug Fixes

1. Cause and Effect Library .project.json file. Resolves OMG issue SYSML2-78 by renaming sysml.library/Domain Libraries/Cause and Effect/.proj.json to .project.json.
   [PR #497]
2. Derivation of AnalysisCaseUsage::resultExpression. Corrects the derivation computation for AnalysisCaseUsage::resultExpresson.
   [PR #498]
3. Defaults for kind properties. Corrects the default values used when serializing to XMI the kind property of various membership relationships.
   [PR #499]

2023-07 - SysML v2 Pilot Implementation

This is an incremental update to the 2023-02 release. It corresponds to Eclipse plugin version 0.34.0.

Note: This is the first release since 2023-02.

Language Features

1. Validation constraints. Most previously unimplemented validation constraints from the Beta 1 versions of the KerML and SysML specifications have now been implemented.
   [PR #486] [PR #487]

Model Libraries

None.

Backward Incompatibilities

1. Validation. Some of the newly implemented validation constraints are already automatically satisfied when a model is parsed from the textual notation. However, the other constraints may cause some models that previously passed validation checking to now fail with errors.

Jupyter

1. %help command. A new %help "magic" command has been added to the Jupyter implementation. Without an argument, this command prints a list of all available magic commands. If given a command name (with or without the initial %) as its argument, it prints the help information for that command (i.e., %helpcmd produces the same result as %cmd -h).
   [PR #493]

Visualization

1. PlantUML
   See Bug Fixes.

2. Tom Sawyer
   None.

Technical Updates

None.

Bug Fixes

1. Rendering of "initial" feature values (PlantUML). Removes the rendering of an unnecessary = along with :=.
   [PR #484]
2. Rendering of feature chains (PlantUML). Corrects the rendering of feature chains at then ends of successions in behavioral diagrams.
   [PR #485]
3. Expression evaluation. Corrects the implementation of integer division and unary Real operator evaluation.
   [PR #488]
4. Derived value computation. Corrects the computation of derived values of various properties.
   [PR #490]
5. Implicit specialization. Corrects the adding of an implicit specialization for declarations that have circular owned specializations.
   [PR #491]
6. Transition usages. Corrects a problem with the setting of the source of a transition usage that could cause spurious warning messages.
   [PR #492]
7. End features. Corrects the implicit redefinition of an end feature whose owner specializes a feature chain.
   [PR #494]
8. Analysis cases. Corrects the computation of the derived value of the resultExpression property for AnalysisCaseDefinitions and AnalysisCaseUsages.
   [PR #495]

2023-02 - SysML v2 Pilot Implementation

This is an incremental update to the 2023-01 release. It corresponds to Eclipse plugin version 0.33.0.

(Note: This is the first public release since 2022-12. There was no public release of 2023-01.)

Language Features

None.

(For Language Feature updates since 2022-12, see the 2023-01 release notes.)

Model Libraries

See Bug Fixes.

Backward Incompatibilities

None.

Jupyter

None.

Visualization

1. PlantUML

   • Perform action usages and exhibit action usages are rendered using the <<perform>> and <<exhibit>> keywords (rather than <<perform action>> and <<exhibit state>>) if the usages have no declared name or short name, but have a reference subsetting.
     [PR #469]

2. Tom Sawyer
   None.

Technical Updates

1. Abstract syntax files. All abstract syntax files have been updated to the 2023-02 baseline, consistent with the latest revised submission to OMG. Changes from 2023-01 are mostly updates to element documentation and addition of OCL constraints, plus two changes to OCL operations:

   • Correction of the return type of ActionUsage::inputParameter from Object to Feature.
   • Addition of the operation FeatureChainExpression::sourceTargetFeature.

   [PR #475]

2. Normative XMI files. Two new QVT transformations have been added to generate .uml files supporting the creation of the normative .xmi files for the KerML and SysML abstract syntax, as delivered in the latest submission to OMG.

   • SysML_xmi.uml – Combined KerML and SysML abstract syntax, but with all levels of packaging from the original MOF model.
   • KerML_only_xmi.uml – Only KerML abstract syntax, with all levels of packaging from the original MOF model.
   • SysML_only_xmi.uml – Only SysML abstract syntax, with all levels of packaging from the original MOF model. Cross-references KerML elements from KerML_only_xmi.uml.

   [PR #473]

Bug Fixes

1. UseCase::includedUseCases. Changed the subsetting of UseCases::UseCase::includedUseCases from subUseCases to enclosedPerformances. This was necessary because includedUseCases is referential (it is subsetted by IncludeUseCaseUsages, which are always referential) and subUseCases is composite.
   [PR #471]
2. Case::obj. Changed the subject of Case::obj to default to Case::result, rather than be bound it. Changed the subject of AnalysisCases::obj to override this default with a binding.
   [PR #474]
3. Empty subjects. Corrects a bug that caused empty subjects to sometimes still be shown when visualized using PlantUML in Juptyer Lab.
   [PR #477]
4. Highlighting. Fixes the highlighting of string, number and "comment" (note) tokens per Xtext configuration for the KerML and SysML editors.
   [PR #478]
5. Validation cases. Resolved "TODO" comments in various validation case models.
   [PR #479]
6. Index expressions. Fixes a bug in the implicit subsetting of index expressions that could cause errors in subsequent references from feature chaining expressions.
   [PR #480]

2023-01 - SysML v2 Pilot Implementation

This is an incremental update to the 2022-12 release. It corresponds to Eclipse plugin version 0.32.0.

(Note: This is an SST-internal release. There is no public release planned for 2023-01.)

Language Features

1. Index expressions. The bracket notation ...[...] for index expressions has been replaced with a new notation ...#(...) (parentheses are required). The bracket notation continues to be used for constructing quantities with units (e.g., 10.0[km]).

   attribute list [*] ordered = ("a", "b", "c");
   attribute a = list#(1); // value is "a"
   attribute b = list#(2); // value is "b"
   
   attribute arr : Collections::Array {
     :>> dimensions = (2, 3);
     :>> elements = ("a", "b", "c",
                     "x", "y", "z");
   }
   attribute c = arr#(1,3); // value is "c"
   attribute y = arr#(2,2); // value is "y"
   

   [PR #466]

2. Timeslices and snapshots. The abstract syntax has been simplified for occurrence usages that are time slices and snapshots, eliminating the concept of a "portioning feature". The textual notation is unchanged, but now time slices and snapshot usages implicitly subset the timeSlices or snapshots features (respectively) of each occurrence definition by which they are explicitly defined, if any, or, otherwise, the occurrence definition or usage in which they are nested.

   occurrence def AircraftFlight {
       // Implicitly subsets "timeSlices" of AircraftFlight.
       timeslice occurrence inAir;
   }
   
   // Implicitly featured by AircraftFlight.
   // Implicitly subsets "timeSlices" of AircraftFlight.
   timeslice occurrence preFlight : AircraftFlight;
   

   [PR #454]

Model Libraries

1. Deterministic UUIDs. Implemented the generation of deterministic, named-based (version 5) UUIDs as the elementIds for standard model library elements with a non-null qualifiedName.
   [PR #457]

Kernel Semantic Library

2. BaseFunctions. Added an abstract function for #.
   [PR #466]
3. SequenceFunctions and CollectionFunctions. Changed the specializations of [ to corresponding specializations of #.
   [PR #466]
4. StatePerformances. Added the feature incomingTransitionTrigger to StatePerformance, whose value is the MessageTransfer accepted to trigger a transition into a StatePerformance. (This is inherited by StateAction in SysML.)
   [PR #455]

Systems Model Library

5. Geometry. Simplified the SpatialItems model to eliminate the need for CompoundSpatialItem. Now, any SpatialItem with one or more componentItems is considered to be a compound union of those items, while a SpatialItem without any compoundItems occurs on its own, separately from its subitems.
   [PR #468]
6. Quantities and Units.
   • Added definitions for curved definitions for curved spatial coordinate frames (3D spherical, cylindrical and planetary) and associated vector quantities in addition to existing Cartesian frames and vectors.
     [PR #406]
   • Added a universalCartesianSpatial3dCoordinateFrame singleton to be used as a default coordinate frame (similar to the Time::universalClock singleton).
     [PR #406]
   • Added a transform calculation definition to VectorCalculations, which transforms a VectorQuantityValue from a source to a target CoordinateFrame.
     [PR #406]
   • Added models for TensorCalculations and MeasurementRefCalculations.
     [PR #467]

Backward Incompatibilities

1. Bracket notation. The following validation checks have been added, to catch previous uses of the bracket notation for indexing:

   • KerML. A warning whenever the bracket notation is used: "Use #(...) for indexing".
   • SysML. A warning when the bracket notation is used and the second argument is not a measurement reference: "Should be a measurement reference (unit)".

   [PR #466]

2. Vector quantities and coordinate frames. A consistent naming convention has been adopted for the names of vector and coordinate frame types and features in library packages Quantities.sysml, MeasurementReferences.sysml and ISQSpaceTime.sysml. As a result, some names of existing elements have changed. The following is an example of successive levels of specialization:

   • VectorQuantityValue, ThreeVectorValue (from KerML)
     • '3dVectorQuantityValue' (alias ThreeDVectorQuantityValue)
       • Position3dVector
         • CartesianPosition3dVector
         • CylindricalPosition3dVector
         • SphericalPosition3dVector
         • PlanetaryPosition3dVector

   [PR #406]

Jupyter

None.

Visualization

1. PlantUML
   None.

2. Tom Sawyer
   None.

Technical Updates

1. Abstract syntax files. The following UML abstract syntax model files are now available in the org.omg.sysml/model directory, reflecting the normative metamodel URIs that will be used for the OMG submission.

   • KerML_only.uml – Contains just the KerML abstract syntax metaclasses, all in a single flat package named kerml.
     URI: https://www.omg.org/spec/KerML/20230201
   • SysML_only.uml – Contains just the SysML abstract syntax metaclasses, all in a single flat package named sysml, referencing KerML elements from KerML_only.uml.
     URI: https://www.omg.org/spec/SysML/20230201
   • SysML.uml – Contains the combined SysML and KerML abstract syntax metaclasses (as before), all in a single flat package named sysml.
     URI: https://www.omg.org/spec/SysML/20230201

   [PR #452]

2. ECore metamodel. Since the Ecore metamodel SysML.ecore is generated from SysML.uml, the sysml EPackage from it is now registered using the URI https://www.omg.org/spec/SysML/20230201 (rather than http://www.omg.org/spec/SysML/2.0, as it has been previously).
   [PR #452]

3. XMI editor features. A omg.org.sysml.editor.feature has been created for the omg.org.sysml.edit and omg.org.sysml.editor plugins introduced in the last release, and this new feature has been added to omg.org.sysml.site for the Eclipse installation.
   [PR #453]

Bug Fixes

1. ControlPerformances. Constrained the earlier/later occurrences of DecisionPerformance::outgoingHBLink/MergePerformance::incomingHBLink to be the performance.
   [PR #456]
2. Links and Transfers. Made the following read-only: Link::participant, BinaryLink::source/target, Transfer::isInstant, FlowTransfer::isMove/isPush.
   [PR #459]
3. Exponential operator. Implemented ^ as an exponential operator for model-level evaluable expression evaluation.
   [PR #460]
4. ItemFlows and FlowConnectionUsages. Corrected the implicit specialization for ItemFlows and FlowConnectionUsages.
   [PR #461]
5. ActionUsages. Corrected the implicit specialization for an ActionUsage as an enclosedPerformance.
   [PR #462]
6. StateActions. Corrected the subsettings of StateAction::entryAction, exitAction and doAction.
   [PR #463]
7. Requirements. Made RequirementCheck::assumptions, constraints, subrequirements and concerns all composite. Also corrected various specializations of Actions::subactions that should have been composite.
   [PR #464]
8. Occurrences.
   • Made Occurrence::self subset spaceTimeCoincidentOccurrences.
     [PR #465]
   • Made Occurrence::spaceTimeCoincidentOccurrences subset timeCoincidentOccurrences (and other related changes).
     [PR #470]

2022-12 - SysML v2 Pilot Implementation

This is an incremental update to the 2022-11 release. It corresponds to Eclipse plugin version 0.31.0.

Language Features

KerML

1. Elements. The Element metaclass is now abstract in the Root abstract syntax. The element notation has therefore been removed from KerML.
   [PR #445]
2. Relationships. The Relationship metaclass is now abstract in the Root abstract syntax. The relationship notation has therefore been removed from KerML.
   [PR #445]
3. Dependencies. Dependency has been added to the Root abstract syntax. The concrete syntax is the same dependency notation as is already in SysML.
   [PR #445]

KerML and SysML

4. Effective names. Effective naming has been extended to short names. If both the declared name and short name of a feature are empty, but it has a naming feature (e.g., a feature it redefines), then it will take both its name and short name from the naming feature.

   part def A {
       attribute <short> longName;
   }
   part def B :> A {
       // This attribute takes both the name "longName" and
       // the short name "short" from its redefined feature.
      attribute redefines longName;
   }
   

   [PR #445]

Model Libraries

Kernel Semantic Library

1. KerML. The reflective KerML model has been updated for abstract syntax changes.
   [PR #445]
2. Occurrences and Performances. Various features related to spatial and temporal modeling associations in the Occurrences and Performances models have been marked as inverses (for example successors and predecessors in Occurrences are inverse features, related to the HappensBefore association). Certain conditions have also been moved from associations to these features.
   [PR #442 and 451]

Systems Model Library

3. SysML. The reflective SysML model has been updated for a small abstract syntax correction.
   [PR #445]
4. StandardViewDefinitions. The number of view definitions in the StandardViewDefinitions package has been reduced from 16 to 9.
   [PR #444]

Backward Incompatibilities

1. Keywords. Removed from KerML: element relationship
   [PR #445]
2. Effective names. The (non-derived) shortName and name properties of Element have been renamed to declaredShortName and declaredName. The (derived) effectiveName property has been renamed to name, and a new, derived shortName property has been added. The property name should be used instead of effectiveName when, e.g., querying for an element using the API.
   [PR #445]
3. Multiplicity. The derivation of the Type::multiplicity property in the abstract syntax has been changed to only select from the owned members of the Type. This means the property will only have a value if the Type has an explicitly declared multiplicity, but not for an implicitly "inherited" multiplicity. (The new utility method FeatureUtil.getMultiplicityOf(Type) implements the previous derivation computation for multiplicity.)
   [PR #448]

Jupyter

None.

Visualization

1. PlantUML

   • Short names. Short names (if not empty) are now shown in textual declarations rendered in compartments.
     [PR #440]
   • XMI visualization. The XMI content of a .sysmlx files can now be visualized by opening it in a basic editor in Eclipse.
     [PR #449]

2. Tom Sawyer
   None.

Technical Updates

None.

Bug Fixes

1. LiteralBoolean. The implemented default for a LiteralBoolean value was created from true to the EMF-generated false.
   [PR #446]
2. Conditional succession. The implicit specialization for TransitionUsages used as conditional succession in action models has been to be the new Action::decisionTransition feature, which is correctly typed by DecisionTransition.
   [PR #447]
3. Connections (PlantUML). Corrected the rendering of connections to redefined features.
   [PR #439]
4. Feature chains (PlantUML). Corrected the rendering of feature chains that start with subsetting or redefining features.
   [PR #443]
5. Feature values (PlantUML). Corrected the rendering of feature values that don't have an = in the textual notation.
   [PR #450]

2022-11 - SysML v2 Pilot Implementation

This is an incremental update to the 2022-10 release. It corresponds to Eclipse plugin version 0.30.0.

Language Features

1. Membership and namespace import. The abstract syntax for Import has been revised so that it is now abstract with two concrete subclasses, MembershipImport and NamespaceImport. The textual and graphical notations are unchanged, but their parsing is different.

   • An import declaration of the form importqualifiedName; now parses to a MembershipImport with its importedMembership given by the resolution of the qualifiedName. If the qualifiedName is suffixed by ::**, then isRecursive = true.
   • An import declaration of the form importqualifiedName::*; now parses to a NamespaceImport with its importedNamespace given by the resolution of the qualifiedName. If ::** is also added, then isRecursive = true.

   [PR #426]

2. Membership and namespace expose. In the SysML abstract syntax, Expose is a kind of Import. Parallel to the abstract syntax change for Import, Expose is now abstract with two concrete subclasses MembershipExpose and NamespaceExpose. ViewUsage has also been updated to replace the exposedNamespace and viewedElement properties with a single exposedElement. As a result of these changes, it is now possible for a ViewUsage to have MembershipExpose relationships to the Memberships for individual elements, even if those elements are not named.
   [PR #426]

Model Libraries

1. KerML and SysML. The reflective syntax models KerML and SysML have been updated to reflect the changes in the abstract syntax for Import and Expose.
   [PR #426]
2. Interchange data. .project and .meta files have been added to each of the model library directories in the sysml.library project, conformant with the format required in subclause 10.2 of the latest KerML Specification. As a result, compressing each of these directories into a ZIP archive results in a legal project interchange (.kpar) file, having model interchange files using the textual notation (.sysml).
   [PR #437]

Backward Incompatibilities

There are no changes to the concrete syntax, so all existing valid models will continue to be valid. However, the abstract syntax for Import and Expose relationships has changed, so import and expose declarations will parse differently than before, as described above.

Jupyter

None.

Visualization

1. PlantUML
   See bug fixes
2. Tom Sawyer
   None.

Technical Updates

1. Eclipse version. The minimum required version for Eclipse installation has been updated to 2022-09.
   [PR #425]

2. JSON schema. The following JSON Schema files have been added to the org.omg.sysml project under a new json-schema directory:

   • KerML.json – KerML abstract syntax (also to be used for API payload validation)
   • SysML.json – SysML abstract syntax (also to be used for API payload validation)
   • ModelInterchange.json – Interchange project information (.project) and interchange project file metadata (.meta)

   [PR #433]

Bug Fixes

1. RequirementDerivation. Corrected the baseTypes for OriginalRequirementMetadata to originalRequirements and DerivedRequirementMetadata to derivedRequirements. These had been switched.
   [PR #432]
2. Feature chain evaluation. Corrected the evaluation of feature chains with intermediate features that are redefined.
   [PR #435]
3. Rendering of subjects (PlantUML). Rendered requirement and case subjects as distinct nodes in order to render subjects with bindings or subsettings.
   [PR #428]
4. Start/done and entry/exit action rendering (PlantUML). Properly rendered start and done in actions and entry and exit actions in states.
   [PR #429]
5. Variant visualization (PlantUML). Revised visualization of variants to align with specification.
   [PR #431]
6. Short name rendering (PlantUML). Fixed an er...

2022-10 - SysML v2 Pilot Implementation

This is an incremental update to the 2022-09 release. It corresponds to Eclipse plugin version 0.29.0.

Language Features

1. User-defined keywords.
   • User-defined keyword notation (#keyword) is now available in KerML.
   • In both KerML and SysML, multiple user-defined keywords can now be used in a single declaration.
2. Binding connectors and successions. In KerML only, it is now possible to declare the ends of a binding connector or succession using end feature declarations in the connector body, rather than using the special notation ... = ... or first ... then ....
3. Cast operators. The parsing of the cast operators as and meta has been changed to make the target type directly the type of the result parameter of the operator expression. (This is a backward compatible change.)
4. Flow payloads. Previously, the textual notation only allowed limited declaration of the name and type of the payload feature (of...) of an item flow (in KerML) or a flow connection usage (in SysML). Now, payload features can have full declarations, including subsetting and redefinition specializations and feature value bindings. This is useful for modeling e.g., a message in SysML with a specific value for its payload.

   message of fuelCommand : FuelCommand = engineController.engineControlPort.incomingFuelCommand
       from engineController to engine;
   

[PR #420]

Model Libraries

1. BaseFunctions. The functions in the Kernel Semantic Library package BaseFunctions corresponding to the cast operators have been updated consistent with the change noted above.
   [PR #420]
2. Connections. See Bug Fixes below.

Backward Incompatibilities

None.

Jupyter

None

Visualization

1. PlantUML

   • Updated PlantUML to 1.2022.7.
     Important Note: To work with this release, existing Eclipse installations will need to have their PlantUML installation updated from the update site https://https://github.com/himi/p2-update-puml-sysmlv2/raw/main/updates.
   • Updated compartment title style to be centered and italic.

   [PR #419]

2. Tom Sawyer
   None.

Technical Updates

There were a number of changes to clean up the abstract syntax, which should not effect user models.

1. Implementation-specific metaclasses. The abstract syntax as implemented previously contained five metaclasses that were specific to the pilot implementation but not considered part of the normative abstract syntax model documented in the specifications. Two of these (ItemFeature and ItemFlowEnd) have now been made normative, while three others (ItemFlowFeature, SourceEnd and TargetEnd) have been removed, with the pilot implementation updated to not need them.
2. Multiplicity lower bounds. Previously, the Feature::type property had a multiplicity lower bound of 1. This has now been changed to 0, as has the multiplicity lower bound for all properties that (directly or indirectly) subset this property. This allows models to be peristed and interchanged without explicit typing, with semanticly necessary types ultimately provided via implied relationships added by tooling.
3. Ecore. Previously, during preprocessing of the exported MOF model, the property Feature::isNonunique was added to SysML.uml for use as an workaround in parsing the nonunique keyword. In addition, the OperatorExpressions::operand property was included in the abstract syntax model as an implementation workaround for parsing operator expressions. Now, these two features are added to SysML.ecore by the custom UML to Ecore converter and are not included in the SysML.uml model.

[PR #420]

Bug Fixes

1. Flow connections. In the Systems Library model Connections, corrected MessageConnection to specialize Actions::Action and messageConnections to specialize Actions::actions.
   [PR #421]

2022-09 - SysML v2 Pilot Implementation

This is an incremental update to the 2022-08 release. It corresponds to Eclipse plugin version 0.28.1.

Language Features

KerML and SysML

1. Library packages. The keyword library can be used to identify a package as a library package, e.g., library packageDynamicsModelLibrary { ... }. Further prefixing a library package declaration with the keyword standard identifies it as a standard library package. However, standard should only be used to identify library packages that are part of the standard KerML and SysML model libraries (i.e., those in the sysml.library project in the pilot implementation), or other accepted standard model libraries in the future.
   [PR #416]

2. Metadata access. A metadata access expression has the form elementName.metadata, where elementName is a qualified name for any kind of element. Such an expression evaluates to a sequence of instances of the reflective metaclass KerML::Metaclass representing the owned metadata feature annotations of the named element, in order. In addition, the last element of the sequence is always an instance of the reflective abstract syntax metaclass for the named element representing the instantiation of the element in the model.

   For example, given the model

   import RiskMetadata::*;
   part def SystemDesign {
       metadata Risk {
           totalRisk = RiskLevelEnum::medium;
       }
   }
   

   The expression SystemDesign.metadata evaluates to a sequence of two values, the first of which is an instance of the metadata definition RiskMetadata::Risk, and the second of which is an instance of SysML::PartDefinition. The following operators are convenient for operating on such sequences of metadata:

   • elementName@@Metaclass is a shorthand for elementName.metadata@Metaclass. It tests whether any of the metadata of the named element is a direct or indirect instance of Metaclass. For example, given the above sample model, the expressions SystemModel @@ Risk and SystemModel @@ SysML::Definition both evaluate to true.
   • elementNamemetaMetaclass is a shorthand for elementName.metadata asMetaclass. It filters the metadata of the named element for only those that are instances of Metaclass. This is useful for accessing the values of features of the metadata. For example, given the above sample model, (SystemDesignmetaRisk).totalRisk.probability evaluates to LevelEnum::medium and (SystemDesignmetaKerML::Element).name evaluates to "SystemDesign" (note that the parentheses are required, due to meta having the operator precedence of a binary operator).

   [PR #416]

3. "Same" operator. The === operator checks if two occurrences are portions of the same life (i.e., have the same "identity"). The operator !== is the inverse of ===. For example, given the model

   part car {
      timeslice drivenByAlice;
      then timeslice drivenByBob;
   }
   

   the expression car.drivenByAlice == car.drivenByBob evaluates to false, because the two timeslices are different occurrences, but car.drivenByAlice === car.drivenByBob evaluates to true, because the two timeslices are both portions of the life of the same car. For data values (i.e., non-occurrences), the === operator is the same as ==.

   Implementation Note: Expression evaluation in the pilot implementation currently does not implement the functionality of === and !== and simply treats them the same as == and !=.
   [PR #417]

SysML Only

4. Conjugated port typing. While the notation for conjugated port typing has not changed, the way the conjugated port definition is resolved has changed. Previously, in a declaration such as portp : ~P;, the conjugated port typing was a relationship between the port usage p and the port definition P, with the actual conjugated port definition being derived as the one owned by P. Now, the conjugated port typing relationship is instead between the port usage and the actual conjugated port definition, which is found by resolving the constructed qualified name P::'~P'. The corresponding port definition P is now a derived property of the conjugated port typing, determined as the owning port definition of the conjugated port definition.
   [PR #416]

5. Send action. Send action syntax has been extended to include a new via clause: sendpayloadviasendertoreceiver;. This allows for arguments for both the sender (via) and receiver (to) parameters of SendAction (see also the model library update description below). While having both via and to is allowed, it is expected that generally only one or the other will be used, with via being used to send "out" through a port (parallel to the use of via on an accept action for accept "in" through a port).
   [PRs #410, #416]

6. Messages. The parsing of message declarations has changed. A declaration of the form message fromsourceEventtotargetEvent; still parses to a connection usage, but without connection ends. Instead, it redefines Transfer::sourceEvent and Transfer::targetEvent to reference the given sourceEvent and targetEvent , respectively (see also model library update description below). This allows such a message to be realized by either a message connection in which the sourceEvent is a send action and the targetEvent is an accept action, or a flow connection, such as between two ports, in which case the source and target ports are also the sourceEvent and targetEvent.
   [PR #410]

Model Libraries

General

1. Library packages. All standard model library packages are now declared as standard library package.
   [PR #416]

2. Reflection. The reflective abstract syntax models KerML and SysML now include all navigable properties from the normative MOF abstract syntax model as features of the corresponding metaclasses/metadata definitions.
   [PR #408]

Kernel Semantic Library

3. Event handling. Updated the models Occurrences, Performances, Transfers, TransitionPerformances and StatePerformances to capture semantics related to event handling, including prioritized dispatch, accept matching and run-to-completion.
   [PR #410]

Kernel Functions Library

4. Base and data functions.

   • Added the abstract function '===' to BaseFunctions, for use as the function invoked by the === operator. Added the function '!==' as the opposite of '===' and the function invoked by the !== operator.
   • Added a specialization of BaseFunctions::'===' for data values to DataFunctions, for which it is the same as '=='.

   [PR #417]

5. Sequence functions. Added the following new functions to SequenceFunctions.

   • same compares whether two sequences are the same using === (as opposed to equals, which uses ==).
   • includingAt returns a sequence of values constructed from two input sequences by adding the second sequence at a given index in the first sequence.
   • excludingAt returns a sequence of values containing all the values from an input sequence except those within a given range of indices (inclusive).

   Added the following behaviors for convenient "standalone" modification of a sequence given with an inout parameter:

   • add adds a sequence of values to the end of the input sequence (using including).
   • addAt adds a sequence of values at a given index of the input sequence (using includingAt).
   • remove removes a set of values from the input sequence (using excluding).
   • removeAt removes the values within a given range of indexes (inclusive) of the input sequence (using excludingAt).

   [PR #417]

6. Occurrence functions. Added a new OccurrenceFunctions package that defines functions that operate on occurrences, primarily related to the time during which those occurrences exist.

   • '===' specializes BaseFunctions::'===' for occurrences. It tests whether two occurrences are portions of the same life. That is, whether they represent different portions of the same entity (colloquially, whether they have the same "identity").
   • isDuring tests whether a performance of the function happens during the input occurrence.
   • create ensures that the start of a given occurrence happens during a performance of this function. The occurrence is also returned from the function.
   • destroy ensures that the end of a given occurrence happens during a performance of this function. The occurrence is also returned from the function.
   • addNew adds a newly created occurrence to the given group of occurrences and returns the new occurrence.
   • addNewAt adds a newly created occurrence to the given ordered group of occurrences at the given index and returns the new occurrence.
   • removeOld removes a given occurrence from a group of occurrences and destroys it.
   • removeOldAt removes the occurrence at a given index in an ordered group of occurrences and destroys it.

   [PR #417]

Systems Library

7. Connections.
   • Added MessageConnection as the most general base type for connection definitions and usages, with FlowConnection as specialization of MessageConnection.
   • Added the features sourceEvent and targetEvent to MessageConnection to identify the events occurrences within the source and target of the connection that create and accept the connection as a transfer, e.g., a source send action and a target accept action. For non-message flow connection usages, sourceEvent and targetEvent default to source and target.

...

2022-08 - SysML v2 Pilot Implementation

This is an incremental update to the 2022-07 release. It corresponds to Eclipse plugin version 0.27.0.

Language Features

KerML

1. Unioning, intersecting and differencing. New relationships have been added for the unioning, intersecting and differencing of types. They are notated using new clauses that can be used in any kind of type declaration (including classifiers, features, connectors, etc.), included in the set of clauses that appear after the specialization part of the declaration.

   • unionsA, B, ... – Specifies that the declared type has unioning relationships with each of the types A, B, ..., meaning that the declared type classifies everything that is classified by any of the listed types.
   • intersectsA, B, ... – Specifies that the declared type has intersecting relationships with each of the types A, B, ..., meaning that the declared type classifies everything that is classified by all of the listed types.
   • differencesA, B, ... – Specifies that the declared type has differencing relationships with each of the types A, B, ..., meaning that the declared type classifies everything that is classified by the first type but is not classified by any of the remaining types.

   class Adult;
   class Child;
   
   class Person unions Adult, Child {
       feature dependents : Child[*];
       feature offspring : Person[*];
       feature grownOffspring : Adult[*] :> offspring;
       feature dependentOffspring : Child[*] :> dependents, offspring 
           differences offspring, grownOffspring 
           intersects dependents, offspring;
   }
   

   [PR #396]

2. Reference subsetting. Previously, the related feature of a connector was related to a connector end using a regular subsetting relationship. Now a special referencing subsetting relationship is used instead, syntactically distinguishing the related feature from other subsetting features the connector end might have. Notationally, this means that, in the named connector end notation, the new keyword references or the equivalent symbol ::> must be used.

   connector :A from a1 ::> f to a2 ::> g;
   connector :B (b1 ::> f, b2 ::> g, b3 ::> h);
   connector :B {
       end b1 references f subsets x;
       end b2 subsets y references g;
       end b3 references h;
   }
   

   [PR #394]

SysML

1. Flow connection definition. Previously, flow connection usages were typed by regular connection definitions specializing the base type FlowConnection. Now flow connection definitions have been added, and flow connection usages must (implicitly or explicitly) be typed by flow connection definitions. The notation is the same as for regular connection definitions, but using the keyword flow def instead of connection def. A flow connection definition is a connection definition, an action definition and a kernel interaction. A flow connection usage is now also an action usage, in addition to being a connection usage and a kernel item flow.
   [PR #390]

2. Reference subsetting. Reference subsetting is also used in the following places in SysML.

   • Connections. To identify the related features of connections, as for KerML connectors (see above).

     connection :A connect a1 ::> f to a2 ::> g;
     connection :B connect (b1 ::> f, b2 ::> g, b3 ::> h);
     connection :B {
        end b1 references f subsets x;
        end b2 subsets y references g;
        end b3 references h;
     }
     

   • Usages. To identify the features referenced by certain kinds of usages.
     • The asserted constraint of an assert constraint usage.
     • The satisfied requirement of a satisfy requirement usage.
     • The event occurrence of an event occurrence usage.
     • The performed action of a perform action usage.
     • The exhibited state of an exhibit state usage.
     • The included use case of an include use case usage.

     perform a; // This is equivalent to the following action.
     perform action references a;
     
     // The performed action is "a" in both of the following.
     perform action a1 references a subsets b;
     perform action a2 :> b ::> a;
     
     satisfy r by p; // This is equivalent to the following satisfy.
     satisfy requirement references r by p;
     

   • Relationships. To identify the features referenced by certain kinds of membership relationships.
     • The constraint referenced by a requirement constraint membership (assume or require).
     • The concern referenced by a framed concern membership (frame).
     • The requirement referenced by a requirement verification membership (verify).
     • The rendering referenced by a view rendering membership (render).

     requirement r {
        require c; // This is equivalent to the following required constraint.
        require constraint references c;
     
        // The referenced constraint is "c" in both of the following.
        assume constraint ac1 references c subsets d;
        assume constraint ac2 :> d ::> c;
     }
     

   • Variants. The notation variantreferenced-usage now parses to a reference usage with a reference subsetting to the referenced-usage. However, there is no surface notational change, and there is no requirement to use reference subsetting otherwise in variant declarations.

     part p;
     variation part q {
        variant p; // This is equivalent to the following.
        variant ref p1 references p;
        variant part p2 subsets p; // But this is also still acceptable.
     }
     

   [PR #394]

3. User-defined keywords. The notation has been updated to allow user-defined keywords in the following additional places.

   • assume#keywordconstraintconstraint-usage
   • require#keywordconstraintconstraint-usage
   • frame#keywordconcernconcern-usage
   • verify#keywordrequirementrequirement-usage
   • actor#keywordusage
   • stakeholder#keywordusage
   • subject#keywordusage
   • objective#keywordrequirement-usage

   Note. In items 1–4, the constraint, concern, or requirement keyword is optional when a user-defined keyword is included. However, if neither keyword is included, then the declaration is a reference, rather than the declaration of a named usage. For example, requireaGoal; is equivalent to require constraint referencesaGoal;, while require #goalaGoal;is equivalent to require #goal constraintaGoal;, where aGoal is a name of the required constraint usage, not a reference to another constraint usage.
   [PR #397]

Model Libraries

Systems Library

1. Connections. FlowConnection and SuccessionFlowConnection have been made flow connection definitions. flowConnections and successionFlowConnections have been made messages (that is, flow connection usages without target output or source input features declared).
   [PR #390]

Backward Incompatibilities

1. Reserved words.
   • KerML: differences intersects references unions
   • SysML: references
2. Reference subsetting. The reference subsetting must now be used in the named notation for the related features of a connector or connection end. In other cases in SysML, reference subsetting should be used to retain the same meaning as previously. For example, in perform actionpasubsetsa; (or perform actionpa :> a;), a is no longer the performed action, it is simply a subsetted action. Instead, use perform actionpareferencesa; (or perform actionpa ::> a;).
   [PR #394]
3. Prefix comments. Prefix comments (i.e, comments starting with /**) will no longer generate a warning. They will simply be parsed as regular comments about the namespace they are a member of (not about the following member). For example, in

   package P {
       /** This is a comment */
       attribute x;
   }
   

   the comment parses as being about package P (not x) with the body text * This is a comment.
   [PR #390]

Jupyter

None.

Visualization

1. PlantUML

   • Updated to visualize language extensions with <<#...>> in the title. In addition, two new styles have been added:
     • HIDEMETADATA – Do not render callouts to show metadata.
     • SHOWMETACLASS – Always show metaclasses for types as well as metadata usages.

   [PR #385]

2. Tom Sawyer
   None.

Technical Updates

None

Bug Fixes

1. ItemFlow::itemType Fixed an error in the implementation of the derivation of itemType that caused an IndexOutOfBoundsException.
   [PR #386]
2. Message ends. Corrected bugs related to the parsing of message declarations.
   [PR #387]
3. Conditional succession. Corrected the computation of the featuring type of an implicit connector/connection.
   [PR #388]
4. Usage::isComposite. Fixed the default for the isComposite property of a usage.
   [PR #389]
5. Conjugate port types (PlantUML). Fixed the rendering of conjugate port types (by using the effective name).
   [PR #391]
6. State actions (PlantUML). Removed the slash from the rendering of state actions.
   [PR #392]
7. Anonymous packages (PlantUML). Fixed the rendering of packages without names.
   [PR #393]
8. Cyclic types (PlantUML). Prevented a StackOverflowException when rendering cyclic types.
   [PR #395]