[1090] Fix the import of MultiplicityRange with lower and upper bounds

gdaniel · AxelRICHARD · commit ed653ccf3ef4 · 2025-05-23T17:17:54.000+02:00
Bug: #1090 Signed-off-by: Gwendal Daniel <gwendal.daniel@obeosoft.com>
diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc
@@ -40,6 +40,8 @@ When creating a new `Perform Action` referencing an existing `Action`, all compa
 - https://github.com/eclipse-syson/syson/issues/1300[#1300] [general-view] Fix wrong tool section name found in some compartments' palette.
 - https://github.com/eclipse-syson/syson/issues/1303[#1303] [general-view] Fix the name of `Constraint` creation tools inside `Requirement`.
 - https://github.com/eclipse-syson/syson/issues/1324[#1324] [details] Fix an issue that prevents ending up with a `null` reference in the reference widget.
+- https://github.com/eclipse-syson/syson/issues/1090[#1090] [import] Fix the textual import of `MultiplicityRange` with lower and upper bounds.
+The import now correctly creates a `MultiplicityRange` containing `LiteralInteger` elements for integer bounds, and `FeatureReferenceExpression` elements for feature bounds.
 
 === Improvements
 
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
@@ -737,4 +737,12 @@ public void checkLiteralString() throws IOException {
                 attribute myAttribute = "value";""";
         this.checker.check(input, input);
     }
+
+    @Test
+    @DisplayName("Given a model with a PartUsage containing a Multiplicity with LiteralInteger bounds, when importing and exporting the model, then the exported text file should be the same as the imported one")
+    public void checkMultiplicityRangeWithLiteralIntegerBounds() throws IOException {
+        var input = """
+                part myPart [1..2];""";
+        this.checker.check(input, input);
+    }
 }
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
@@ -19,6 +19,7 @@
 
 import java.io.IOException;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.UUID;
 
@@ -38,6 +39,7 @@
 import org.eclipse.syson.AbstractIntegrationTests;
 import org.eclipse.syson.services.UtilService;
 import org.eclipse.syson.sysml.ActionUsage;
+import org.eclipse.syson.sysml.AttributeUsage;
 import org.eclipse.syson.sysml.ConjugatedPortDefinition;
 import org.eclipse.syson.sysml.DecisionNode;
 import org.eclipse.syson.sysml.Expression;
@@ -47,6 +49,7 @@
 import org.eclipse.syson.sysml.LiteralInteger;
 import org.eclipse.syson.sysml.LiteralString;
 import org.eclipse.syson.sysml.Membership;
+import org.eclipse.syson.sysml.MultiplicityRange;
 import org.eclipse.syson.sysml.OperatorExpression;
 import org.eclipse.syson.sysml.PartUsage;
 import org.eclipse.syson.sysml.PortDefinition;
@@ -642,6 +645,89 @@ public void checkAttributeUsageLiteralStringValueTest() throws IOException {
         }).check(input);
     }
 
+    @Test
+    @DisplayName("Given a PartUsage with a Multiplicity with LiteralInteger bounds, when importing the model, then the Multiplicity value is set")
+    public void checkPartUsageMultiplicityLiteralIntegerBoundsValueTest() throws IOException {
+        var input = """
+                part myPart[1..2];
+                """;
+        this.checker.checkImportedModel(resource -> {
+            List<PartUsage> partUsages = EMFUtils.allContainedObjectOfType(resource, PartUsage.class).toList();
+            assertThat(partUsages).hasSize(1);
+            PartUsage partUsage = partUsages.get(0);
+            assertThat(partUsage.getMultiplicity()).isInstanceOf(MultiplicityRange.class);
+            MultiplicityRange multiplicityRange = (MultiplicityRange) partUsage.getMultiplicity();
+            assertThat(multiplicityRange.getLowerBound()).isInstanceOf(LiteralInteger.class);
+            LiteralInteger multiplicityRangerLowerBound = (LiteralInteger) multiplicityRange.getLowerBound();
+            assertThat(multiplicityRangerLowerBound.getValue()).isEqualTo(1);
+            assertThat(multiplicityRange.getUpperBound()).isInstanceOf(LiteralInteger.class);
+            LiteralInteger multiplicityRangeUpperBound = (LiteralInteger) multiplicityRange.getUpperBound();
+            assertThat(multiplicityRangeUpperBound.getValue()).isEqualTo(2);
+        }).check(input);
+    }
+
+    @Test
+    @DisplayName("Given a PartUsage with a Multiplicity with FeatureReferenceExpression bounds, when importing the model, then the Multiplicity value is set")
+    public void checkPartUsageMultiplicityChainedFeatureReferenceExpressionBoundsTest() throws IOException {
+        // The result of the bound expression(s) of a MultiplicityRange must be typed by ScalarValues::Integer (see
+        // KerML 8.3.4.11.2).
+        var input = """
+                part bounds {
+                    attribute lower:ScalarValues::Integer = 1;
+                    part upperBounds {
+                        attribute upper:ScalarValues::Integer = 2;
+                    }
+                }
+
+                part myPart[bounds::lower..bounds::upperBounds::upper];
+                """;
+        this.checker.checkImportedModel(resource -> {
+            Optional<PartUsage> optionalPartUsage = EMFUtils.allContainedObjectOfType(resource, PartUsage.class)
+                    .filter(partUsage -> Objects.equals(partUsage.getName(), "myPart"))
+                    .findFirst();
+            assertThat(optionalPartUsage).isPresent();
+            assertThat(optionalPartUsage.get().getMultiplicity()).isInstanceOf(MultiplicityRange.class);
+            MultiplicityRange multiplicityRange = (MultiplicityRange) optionalPartUsage.get().getMultiplicity();
+            assertThat(multiplicityRange.getLowerBound()).isInstanceOf(FeatureReferenceExpression.class);
+            FeatureReferenceExpression multiplicityRangeLowerBound = (FeatureReferenceExpression) multiplicityRange.getLowerBound();
+            assertThat(multiplicityRangeLowerBound.getReferent())
+                    .isInstanceOf(AttributeUsage.class)
+                    .returns("lower", Feature::getName);
+            assertThat(multiplicityRange.getUpperBound()).isInstanceOf(FeatureReferenceExpression.class);
+            FeatureReferenceExpression multiplicityRangeUpperBound = (FeatureReferenceExpression) multiplicityRange.getUpperBound();
+            assertThat(multiplicityRangeUpperBound.getReferent())
+                    .isInstanceOf(AttributeUsage.class)
+                    .returns("upper", Feature::getName);
+        }).check(input);
+    }
+
+    @Test
+    @DisplayName("Given a PartUsage with a Multiplicity with top-level FeatureReferenceExpression bounds, when importing the model, then the Multiplicity value is set ")
+    public void checkPartUsageMultiplicityTopLevelFeatureReferenceExpressionBoundTest() throws IOException {
+        var input = """
+                attribute lower:ScalarValues::Integer = 1;
+                attribute upper:ScalarValues::Integer = 2;
+                part myPart[lower..upper];
+                """;
+        this.checker.checkImportedModel(resource -> {
+            List<PartUsage> partUsages = EMFUtils.allContainedObjectOfType(resource, PartUsage.class).toList();
+            assertThat(partUsages).hasSize(1);
+            PartUsage partUsage = partUsages.get(0);
+            assertThat(partUsage.getMultiplicity()).isInstanceOf(MultiplicityRange.class);
+            MultiplicityRange multiplicityRange = (MultiplicityRange) partUsage.getMultiplicity();
+            assertThat(multiplicityRange.getLowerBound()).isInstanceOf(FeatureReferenceExpression.class);
+            FeatureReferenceExpression multiplicityRangeLowerBound = (FeatureReferenceExpression) multiplicityRange.getLowerBound();
+            assertThat(multiplicityRangeLowerBound.getReferent())
+                    .isInstanceOf(AttributeUsage.class)
+                    .returns("lower", Feature::getName);
+            assertThat(multiplicityRange.getUpperBound()).isInstanceOf(FeatureReferenceExpression.class);
+            FeatureReferenceExpression multiplicityRangeUpperBound = (FeatureReferenceExpression) multiplicityRange.getUpperBound();
+            assertThat(multiplicityRangeUpperBound.getReferent())
+                    .isInstanceOf(AttributeUsage.class)
+                    .returns("upper", Feature::getName);
+        }).check(input);
+    }
+
     private void assertOperatorExpressionGuard(TransitionUsage t1, String expectedOperator, Class<?> expectedFirstParameterType, Class<?> expectedSecondParameterType) {
         EList<Expression> guardExpression1 = t1.getGuardExpression();
         assertThat(guardExpression1).hasSize(1);
diff --git a/backend/application/syson-sysml-import/pom.xml b/backend/application/syson-sysml-import/pom.xml
@@ -67,6 +67,11 @@
 			<artifactId>syson-sysml-metamodel</artifactId>
 			<version>2025.4.5</version>
 		</dependency>
+		<dependency>
+			<groupId>org.eclipse.syson</groupId>
+			<artifactId>syson-services</artifactId>
+			<version>2025.4.5</version>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-test</artifactId>
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
@@ -22,6 +22,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;
+import java.util.Objects;
 
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EObject;
@@ -30,6 +31,7 @@
 import org.eclipse.sirius.components.emf.services.JSONResourceFactory;
 import org.eclipse.sirius.components.representations.Message;
 import org.eclipse.sirius.components.representations.MessageLevel;
+import org.eclipse.syson.services.DeleteService;
 import org.eclipse.syson.sysml.helper.EMFUtils;
 import org.eclipse.syson.sysml.parser.AstTreeParser;
 import org.eclipse.syson.sysml.parser.ContainmentReferenceHandler;
@@ -161,6 +163,36 @@ private void addInParent(Element parent, Element child) {
     private void postResolvingFixingPhase(List<? extends EObject> rootSysmlObjects) {
         for (EObject root : rootSysmlObjects) {
             this.fixTransitionUsageImplicitSource(root);
+            this.fixOperatorExpressionUsedAsRanges(root);
+        }
+    }
+
+    private void fixOperatorExpressionUsedAsRanges(EObject root) {
+        // Only get the OperatorExpressions used in MultiplicityRange. Based on KerML 8.2.5.8.1 OperatorExpression
+        // referring to the ".." function can exist, but the specification does not allow them in MultiplicityRange (see
+        // SysML 8.2.2.6.6 and KerML 8.2.5.11).
+        List<OperatorExpression> operatorExpressions = EMFUtils.allContainedObjectOfType(root, MultiplicityRange.class)
+                .flatMap(multiplicityRange -> multiplicityRange.getOwnedMember().stream())
+                .filter(OperatorExpression.class::isInstance)
+                .map(OperatorExpression.class::cast)
+                .filter(operatorExpression -> Objects.equals(operatorExpression.getOperator(), ".."))
+                .toList();
+        for (OperatorExpression operatorExpression : operatorExpressions) {
+            Element owner = operatorExpression.getOwner();
+            for (Feature parameter : operatorExpression.getParameter()) {
+                Expression parameterValue = parameter.getValuation().getValue();
+                // Only LiteralExpressions and FeatureReferenceExpressions can be used in a MultiplicityRange
+                if (parameterValue instanceof LiteralExpression || parameterValue instanceof FeatureReferenceExpression) {
+                    OwningMembership newOwningMembership = SysmlFactory.eINSTANCE.createOwningMembership();
+                    owner.getOwnedRelationship().add(newOwningMembership);
+                    newOwningMembership.getOwnedRelatedElement().add(parameterValue);
+                }
+            }
+            if (operatorExpression.getOwningMembership() != null) {
+                new DeleteService().deleteFromModel(operatorExpression.getOwningMembership());
+            } else {
+                new DeleteService().deleteFromModel(operatorExpression);
+            }
         }
         this.logger.info("Post resolving fixing phase done");
     }
diff --git a/doc/content/modules/user-manual/pages/release-notes/2025.6.0.adoc b/doc/content/modules/user-manual/pages/release-notes/2025.6.0.adoc
@@ -39,6 +39,8 @@ They are now named:
 * `New Assume constraint`
 
 - In the _Details_ view, fix an issue that prevents opening the candidates on a reference widget.
+- Fix an issue in the textual import of `MultiplicityRange` with explicit lower and upper bounds.
+The textual import now correctly creates a `MultiplicityRange` containing `LiteralInteger` elements for integer bounds, and `FeatureReferenceExpression` elements for feature bounds.
 
 == New features
 

Original file line number	Diff line number	Diff line change
`@@ -737,4 +737,12 @@ public void checkLiteralString() throws IOException {`
`737`	`737`	`attribute myAttribute = "value";""";`
`738`	`738`	`this.checker.check(input, input);`
`739`	`739`	`}`
	`740`	`+`
	`741`	`+ @Test`
	`742`	`+ @DisplayName("Given a model with a PartUsage containing a Multiplicity with LiteralInteger bounds, when importing and exporting the model, then the exported text file should be the same as the imported one")`
	`743`	`+ public void checkMultiplicityRangeWithLiteralIntegerBounds() throws IOException {`
	`744`	`+ var input = """`
	`745`	`+ part myPart [1..2];""";`
	`746`	`+ this.checker.check(input, input);`
	`747`	`+ }`
`740`	`748`	`}`