[1042] Improve SuccessionAsUsage defining new the actions

adaussy · AxelRICHARD · commit 82e702ae2f50 · 2025-03-04T15:25:16.000+01:00
Bug: #1042 Signed-off-by: Arthur Daussy <arthur.daussy@obeo.fr>
diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc
@@ -30,6 +30,7 @@ A new dra & drop tool is available on the diagram, allowing moving `Satisfy Requ
 - [explorer] The `General View` diagram is now proposed first when creating a diagram.
 - https://github.com/eclipse-syson/syson/issues/1024[#1024] [diagrams] Allow `Usage` and `Definition` graphical node labels to be wrapped to handle long names more easily.
 - https://github.com/eclipse-syson/syson/issues/1030[#1030] [metamodel] `ConnectorAsUsage.getSourceFeature` and `ConnectorAsUsage.getTargetFeature` should redefine `Relationship.source` and `Relationship.target` features
+- https://github.com/eclipse-syson/syson/issues/1042[#1042] [import] Improve textual import of `SuccessionAsUsage` which define a new target action directly after the 'then' keyword.
 
 === New features
 
diff --git a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/export/ImportExportTests.java b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/export/ImportExportTests.java
@@ -70,6 +70,38 @@ public void checkSuccessionAsUsageImplicitSourceTest() throws IOException {
         this.checker.check(input, input);
     }
 
+    @Test
+    @DisplayName("Given a SuccessionAsUsage with target defined after the then keyword, when importing and exporting the model,  then the exported text file should be semantically equal.")
+    public void checkSuccessionDefiningImplicitTarget() throws IOException {
+        var input = """
+                action def ActionDef1 {
+                    action a0;
+                    first a0;
+                    then action a1;
+                    then action a2;
+                }""";
+        /**
+         * Here we have differences here because :
+         *
+         * <ul>
+         * <li>The construction of SuccessionAsUsage defining new ActionUsage is hard to detect so we chose to use the
+         * complete syntax "first source then target;"</li>
+         * <li>The current implementation of implicit specialization causes some issues during name de-resolution see
+         * https://github.com/eclipse-syson/syson/issues/1029</li>
+         * <ul>
+         */
+        var expected = """
+                action def ActionDef1 {
+                    action a0;
+                    then ActionDef1::a1;
+                    action a1;
+                    then ActionDef1::a2;
+                    action a2;
+                }""";
+
+        this.checker.check(input, expected);
+    }
+
     @Test
     @DisplayName("Given a SuccessionAsUsage with an implicit source feature targeting the 'start' standard library element, when importing and exporting the model, then the exported text file should be semantically equal.")
     public void checkSuccessionAsUsageImplicitSourceToStartTest() throws IOException {
@@ -124,13 +156,9 @@ public void checkSuccessionAsUsageExplicitSourceTest() throws IOException {
     @Test
     public void checkUseCaseTest() throws IOException {
         /*
-         * The file has been modified because a problem has been detected during the export phase.
-         * Those problem force us to use some full-length qualified name. This should be investigated.
-         *
-         * for example:
-                include UseCaseTest::uc2;
-         * instead of
-                include uc2;
+         * The file has been modified because a problem has been detected during the export phase. Those problem force
+         * us to use some full-length qualified name. This should be investigated. for example: include
+         * UseCaseTest::uc2; instead of include uc2;
          */
         var input = """
                 package UseCaseTest {
@@ -242,18 +270,15 @@ public void checkScalarValueAttribute() throws IOException {
     /**
      * Test import/export on test file ImportTest.sysml.
      *
-     * @see <a href="https://github.com/Systems-Modeling/SysML-v2-Release/blob/master/sysml/src/examples/Simple%20Tests/ImportTest.sysml">ImportTest</a>
+     * @see <a href=
+     *      "https://github.com/Systems-Modeling/SysML-v2-Release/blob/master/sysml/src/examples/Simple%20Tests/ImportTest.sysml">ImportTest</a>
      */
     @Test
     public void checkImportTest() throws IOException {
         /*
-         * The file has been modified because a problem has been detected during the export phase.
-         * Those problem force us to use some full-length qualified name. This should be investigated.
-         *
-         * for example:
-                private import Pkg2::Pkg21::Pkg211::*::**;
-         * instead of
-                private import Pkg211::*::**;
+         * The file has been modified because a problem has been detected during the export phase. Those problem force
+         * us to use some full-length qualified name. This should be investigated. for example: private import
+         * Pkg2::Pkg21::Pkg211::*::**; instead of private import Pkg211::*::**;
          */
         var input = """
                 package ImportTest {
@@ -335,7 +360,8 @@ public void checkConcernTest() throws IOException {
     /**
      * Test import/export on test file OccurrenceTest.sysml.
      *
-     * @see <a href="https://github.com/Systems-Modeling/SysML-v2-Release/blob/master/sysml/src/examples/Simple%20Tests/OccurrenceTest.sysml">OccurrenceTest</a>
+     * @see <a href=
+     *      "https://github.com/Systems-Modeling/SysML-v2-Release/blob/master/sysml/src/examples/Simple%20Tests/OccurrenceTest.sysml">OccurrenceTest</a>
      */
     @Test
     public void checkOccurrenceTest() throws IOException {
diff --git a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/imports/ImportSysMLModelTest.java b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/imports/ImportSysMLModelTest.java
@@ -62,6 +62,33 @@ public void setUp() {
         this.checker = new SysMLv2SemanticImportChecker(this.sysmlResourceLoader, this.editingDomainFactory, this.sysMLEditingContextProcessor);
     }
 
+    @Test
+    @DisplayName("Given a SuccessionAsUsage using the syntax that create a new target action, when importing and exporting the model, then the source and target should be correctly computed.")
+    public void checkSuccessionToDefinedActionSourceTest() throws IOException {
+        var input = """
+                action def ActionDef1 {
+                    first start;
+                    then action a1;
+                    then action a2;
+                }""";
+
+        this.checker.checkImportedModel(resource -> {
+            List<SuccessionAsUsage> successionAsUsages = EMFUtils.allContainedObjectOfType(resource, SuccessionAsUsage.class).toList();
+
+            assertThat(successionAsUsages).hasSize(2);
+
+            SuccessionAsUsage firstToA1 = successionAsUsages.get(0);
+
+            assertThat(firstToA1.getSourceFeature().getName()).isEqualTo("start");
+            assertThat(firstToA1.getTargetFeature()).hasSize(1).allMatch(f -> "a1".equals(f.getName()));
+
+            SuccessionAsUsage firstToA2 = successionAsUsages.get(1);
+
+            assertThat(firstToA2.getSourceFeature().getName()).isEqualTo("a1");
+            assertThat(firstToA2.getTargetFeature()).hasSize(1).allMatch(f -> "a2".equals(f.getName()));
+        }).check(input);
+    }
+
     @Test
     @DisplayName("Given a SuccessionAsUsage with an implicit source feature targeting the 'start' standard library element, "
             + "when importing the model, "
diff --git a/backend/application/syson-sysml-import/src/main/java/org/eclipse/syson/sysml/ASTTransformer.java b/backend/application/syson-sysml-import/src/main/java/org/eclipse/syson/sysml/ASTTransformer.java
@@ -36,6 +36,7 @@
 import org.eclipse.syson.sysml.parser.NonContainmentReferenceHandler;
 import org.eclipse.syson.sysml.parser.ProxiedReference;
 import org.eclipse.syson.sysml.parser.ProxyResolver;
+import org.eclipse.syson.sysml.util.ElementUtil;
 import org.eclipse.syson.sysml.utils.MessageReporter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -101,8 +102,43 @@ private void preResolvingFixingPhase(List<EObject> rootSysmlObjects) {
      *            a root element.
      */
     private void fixSuccessionUsageImplicitSource(EObject root) {
-        EMFUtils.allContainedObjectOfType(root, SuccessionAsUsage.class)
-                .filter(this::hasImplicitSourceFeature)
+        List<SuccessionAsUsage> succesionAsUsage = EMFUtils.allContainedObjectOfType(root, SuccessionAsUsage.class).toList();
+        this.fixImplicitSourceFeature(succesionAsUsage);
+        this.fixImplicitTarget(succesionAsUsage);
+    }
+
+    /**
+     * Try to fix all {@link SuccessionAsUsage} elements contained in the given root to workaround
+     * https://github.com/eclipse-syson/syson/issues/1042 and https://github.com/sensmetry/sysml-2ls/issues/13.
+     *
+     * @param root
+     *            a root element.
+     */
+    private void fixImplicitTarget(List<SuccessionAsUsage> succesionAsUsage) {
+        succesionAsUsage.stream().filter(this::hasImplicitTargetFeature)
+                .forEach(suc -> {
+                    Feature invalidFeature = suc.getConnectorEnd().get(1);
+                    FeatureMembership owningFeatureMembershit = invalidFeature.getOwningFeatureMembership();
+                    ReferenceUsage refUsage = SysmlFactory.eINSTANCE.createReferenceUsage();
+                    EList<Element> ownedRelatedElements = owningFeatureMembershit.getOwnedRelatedElement();
+
+                    Membership previousMembershipFeature = this.computeTargetFeatureMembership(suc);
+                    if (previousMembershipFeature != null && ElementUtil.isFromLibrary(previousMembershipFeature.getMemberElement(), true)) {
+                        // For implicit target that targets an element of the standard library, we need to keep a
+                        // "virtual link" to the previous feature membership to identify the source of SuccessionAsUsage
+                        // see implementation :
+                        // org.eclipse.syson.diagram.common.view.services.ViewCreateService.createEndFeatureMembershipFor(Element)
+                        refUsage.getAliasIds().add(previousMembershipFeature.getElementId());
+                    }
+
+                    int index = ownedRelatedElements.indexOf(invalidFeature);
+                    ownedRelatedElements.remove(index);
+                    ownedRelatedElements.add(index, refUsage);
+                });
+    }
+
+    private void fixImplicitSourceFeature(List<SuccessionAsUsage> succesionAsUsage) {
+        succesionAsUsage.stream().filter(this::hasImplicitSourceFeature)
                 .forEach(suc -> {
                     Feature invalidFeature = suc.getConnectorEnd().get(0);
                     FeatureMembership owningFeatureMembershit = invalidFeature.getOwningFeatureMembership();
@@ -142,6 +178,26 @@ private Membership computePreviousFeatureMembership(SuccessionAsUsage succession
         return null;
     }
 
+    private Membership computeTargetFeatureMembership(SuccessionAsUsage successionAsUsage) {
+        Type owningType = successionAsUsage.getOwningType();
+        if (owningType != null) {
+
+            EList<Membership> ownedMemberships = owningType.getOwnedMembership();
+            int index = ownedMemberships.indexOf(successionAsUsage.getOwningMembership());
+            if (index > 0 && ownedMemberships.size() > index) {
+                ListIterator<Membership> iterator = ownedMemberships.subList(index + 1, ownedMemberships.size()).listIterator();
+                while (iterator.hasNext()) {
+                    Membership next = iterator.next();
+                    if (next.getMemberElement() instanceof Feature) {
+                        return next;
+                    }
+                }
+            }
+
+        }
+        return null;
+    }
+
     private boolean hasImplicitSourceFeature(SuccessionAsUsage successionUsage) {
         EList<Feature> ends = successionUsage.getConnectorEnd();
         if (!ends.isEmpty()) {
@@ -151,6 +207,15 @@ private boolean hasImplicitSourceFeature(SuccessionAsUsage successionUsage) {
         return false;
     }
 
+    private boolean hasImplicitTargetFeature(SuccessionAsUsage successionUsage) {
+        EList<Feature> ends = successionUsage.getConnectorEnd();
+        if (ends.size() > 1) {
+            Feature sourceEnd = ends.get(1);
+            return sourceEnd.eClass() == SysmlPackage.eINSTANCE.getFeature() && sourceEnd.getOwnedRelationship().isEmpty();
+        }
+        return false;
+    }
+
     public List<Message> getTransformationMessages() {
         return this.messageReporter.getReportedMessages();
     }
diff --git a/backend/metamodel/syson-sysml-metamodel/src/main/java/org/eclipse/syson/sysml/helper/ImplicitSpecializationSwitch.java b/backend/metamodel/syson-sysml-metamodel/src/main/java/org/eclipse/syson/sysml/helper/ImplicitSpecializationSwitch.java
@@ -203,11 +203,17 @@ private List<Specialization> handleReferenceUsageInSuccessionAsUsage(ReferenceUs
         // At this moment we only handle the case of implicit source since we haven't found a
         // case where the target is implicit
         int index = parentSuccessionAsUsage.getOwnedFeature().indexOf(referenceUsage);
+        boolean hasNoExpliciteSubsetting = this.getOwnedRelations(ReferenceSubsetting.class, referenceUsage).isEmpty();
         if (index == 0 && this.getOwnedRelations(ReferenceSubsetting.class, referenceUsage).isEmpty()) {
             // Source feature
-            // Add a reference ReferenceSubsetting to the previous setting
+            // Add a reference ReferenceSubsetting to the previous feature
             Feature sourceFeature = this.computeSourceFeature(parentSuccessionAsUsage);
             result = List.of(this.implicitReferenceSubsetting(referenceUsage, sourceFeature));
+        } else if (index == 1 && hasNoExpliciteSubsetting) {
+            // Target feature
+            // Add a reference ReferenceSubsetting to the next feature
+            Feature targetFeature = this.computeTargetFeature(parentSuccessionAsUsage);
+            result = List.of(this.implicitReferenceSubsetting(referenceUsage, targetFeature));
         } else {
             result = List.of();
         }
@@ -1436,6 +1442,24 @@ private FeatureTyping implicitTyping(Feature feature, String implicitTypeQualifi
         return null;
     }
 
+    private Feature computeTargetFeature(SuccessionAsUsage successionAsUsage) {
+        Type owningType = successionAsUsage.getOwningType();
+        if (owningType != null) {
+            EList<Membership> ownedMemberships = owningType.getOwnedMembership();
+            int index = ownedMemberships.indexOf(successionAsUsage.getOwningMembership());
+            if (index > 0 && ownedMemberships.size() > index) {
+                ListIterator<Membership> iterator = ownedMemberships.subList(index + 1, ownedMemberships.size()).listIterator();
+                while (iterator.hasNext()) {
+                    Membership next = iterator.next();
+                    if (next.getMemberElement() instanceof Feature feature) {
+                        return feature;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
     private boolean hasRedefinition(Element element) {
         return this.existingSpecializations.stream().anyMatch(Redefinition.class::isInstance);
     }
diff --git a/doc/content/modules/user-manual/pages/release-notes/2025.4.0.adoc b/doc/content/modules/user-manual/pages/release-notes/2025.4.0.adoc
@@ -26,7 +26,7 @@ image::release-notes-create-diagram-on-root-namespace-element.png[Create diagram
 
 image::release-notes-gv-subject-creation-selection-dialog-tree.png['subject creation tool selection dialog tree' compartment, width=50%, height=50%]
 
-- Improve handling of `SuccessionAsUsage` textual import with implicit source feature.
+- Improve handling of `SuccessionAsUsage` textual import with implicit _source_ property.
 For example importing the following SysMLv2 content would now create a valid semantic model:
 
 ```
@@ -50,6 +50,16 @@ image::release-notes-gv-satisfy-requirement-usage.png[Satisfy Requirement Usage
 - The `General View` diagram is now proposed first when creating a diagram.
 - It is now possible, in diagrams, to reduce the width of `Usages` (e.g. `Part`) and `Definition` (e.g. `Part Definition`) graphical nodes with a long name as their label can now be wrapped.
 
+- Improve textual import of `SuccessionAsUsage` which define a new target action directly after the 'then' keyword.
+For example importing the following SysML file would now create a valid semantic model:
+
+```
+ action def ActionDef1 {
+    first start;
+    then action a1;
+    then action a2;
+}
+```
 
 == Dependency update
 
