[2251] Allow expression-related operations on their parent element

Bug: #2251
Signed-off-by: Pierre-Charles David <pierre-charles.david@obeo.fr>

Author: pcdavid

CHANGELOG.adoc

@@ -31,6 +31,7 @@
 Before, the selection dialog option with selection allowed choosing between all _timeslice/snapshot_ types.
 Now, the choice is restricted to the _timeslice/snapshot_ type that match the graphical node type on which the tool is applied.
 - https://github.com/eclipse-syson/syson/issues/2119[#2119] [details] Display expressions values in the _Details_ view and allow to edit them from there.
+- https://github.com/eclipse-syson/syson/issues/2251[#2251] [explorer] Allow expression-related operations on their parent element
 
 === New features
 

backend/application/syson-application-configuration/src/main/java/org/eclipse/syson/application/configuration/SysMLv2PropertiesConfigurer.java

@@ -192,6 +192,7 @@ private FormDescription createDetailsViewForElement() {
         pageCore.getGroups().add(this.createExtraTransitionSourceTargetPropertiesGroup());
         pageCore.getGroups().add(this.createFeatureValuePropertiesGroup());
         pageCore.getGroups().add(this.createExpressionPropertiesGroup());
+        pageCore.getGroups().add(this.createResultExpressionPropertiesGroup());
 
         PageDescription pageAdvanced = FormFactory.eINSTANCE.createPageDescription();
         pageAdvanced.setName("SysON-DetailsView-Advanced");
@@ -243,7 +244,7 @@ private GroupDescription createFeatureValuePropertiesGroup() {
 
         TextAreaDescription expressionWidget = FormFactory.eINSTANCE.createTextAreaDescription();
         expressionWidget.setName("ValueExpression");
-        expressionWidget.setLabelExpression("Value");
+        expressionWidget.setLabelExpression(CUSTOM_EXPRESSION_WIDGET_KEY);
         expressionWidget.setValueExpression(ServiceMethod.of0(DetailsViewService::getValueExpressionTextualRepresentation).aqlSelf());
         expressionWidget.setIsEnabledExpression(AQLConstants.AQL_FALSE);
 
@@ -252,6 +253,29 @@ private GroupDescription createFeatureValuePropertiesGroup() {
         return group;
     }
 
+    /**
+     * Creates a group to display the value of a ResultExpression.
+     *
+     * @return a {@link GroupDescription}
+     */
+    private GroupDescription createResultExpressionPropertiesGroup() {
+        GroupDescription group = FormFactory.eINSTANCE.createGroupDescription();
+        group.setDisplayMode(GroupDisplayMode.LIST);
+        group.setName("Result");
+        group.setLabelExpression("");
+        group.setSemanticCandidatesExpression(ServiceMethod.of0(DetailsViewService::getResultExpression).aqlSelf());
+
+        TextAreaDescription expressionWidget = FormFactory.eINSTANCE.createTextAreaDescription();
+        expressionWidget.setName("ResultExpression");
+        expressionWidget.setLabelExpression(CUSTOM_EXPRESSION_WIDGET_KEY);
+        expressionWidget.setValueExpression(ServiceMethod.of0(DetailsViewService::getResultExpressionTextualRepresentation).aqlSelf());
+        expressionWidget.setIsEnabledExpression(AQLConstants.AQL_FALSE);
+
+        group.getChildren().add(expressionWidget);
+
+        return group;
+    }
+
     private GroupDescription createCorePropertiesGroup() {
         GroupDescription group = FormFactory.eINSTANCE.createGroupDescription();
         group.setDisplayMode(GroupDisplayMode.LIST);

backend/application/syson-application-configuration/src/main/java/org/eclipse/syson/application/expressions/services/ExpressionTextualRepresentationEventHandler.java

@@ -23,6 +23,7 @@
 import org.eclipse.sirius.components.core.api.IPayload;
 import org.eclipse.syson.application.expressions.dto.ExpressionTextualRepresentationInput;
 import org.eclipse.syson.application.expressions.dto.ExpressionTextualRepresentationPayload;
+import org.eclipse.syson.sysml.Element;
 import org.eclipse.syson.sysml.Expression;
 import org.eclipse.syson.sysml.metamodel.services.MetamodelQueryElementService;
 import org.springframework.stereotype.Service;
@@ -55,14 +56,38 @@ public boolean canHandle(IEditingContext editingContext, IInput input) {
     public void handle(Sinks.One<IPayload> payloadSink, Sinks.Many<ChangeDescription> changeDescriptionSink, IEditingContext editingContext, IInput input) {
         String textualRepresentation = "";
         if (input instanceof ExpressionTextualRepresentationInput expressionTextualRepresentationInput) {
-            Optional<Expression> optionalExpression = this.objectSearchService.getObject(editingContext, expressionTextualRepresentationInput.elementId())
-                    .filter(Expression.class::isInstance)
-                    .map(Expression.class::cast)
-                    .filter(this.metamodelQueryElementService::isTopLevelExpression);
+            String elementId = expressionTextualRepresentationInput.elementId();
+            Optional<Expression> optionalExpression = this.getExpression(editingContext, elementId);
             if (optionalExpression.isPresent()) {
                 textualRepresentation = this.metamodelQueryElementService.getExpressionTextualRepresentation(optionalExpression.get());
             }
         }
         payloadSink.tryEmitValue(new ExpressionTextualRepresentationPayload(input.id(), textualRepresentation));
     }
+
+    /**
+     * Finds the {@link Expression} element to consider given the provided {@code elementId}.
+     *
+     * @param editingContext
+     *            the editing context.
+     * @param elementId
+     *            either to id of an actual {@link Expression} element, or of the parent {@link Element} of a single
+     *            {@code Expression}.
+     * @return the directly of indirectly designated {@link Expression}.
+     */
+    private Optional<Expression> getExpression(IEditingContext editingContext, String elementId) {
+        Optional<Expression> result = Optional.empty();
+        Optional<Element> optionalElement = this.objectSearchService.getObject(editingContext, elementId)
+                .filter(Element.class::isInstance)
+                .map(Element.class::cast);
+        if (optionalElement.isPresent()) {
+            Element element = optionalElement.get();
+            if (element instanceof Expression expression && this.metamodelQueryElementService.isTopLevelExpression(expression)) {
+                result = optionalElement.map(Expression.class::cast);
+            } else {
+                result = this.metamodelQueryElementService.findSingleExpressionDefinition(element);
+            }
+        }
+        return result;
+    }
 }

backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/expressions/ExpressionsControllersIntegrationTests.java

@@ -553,18 +553,21 @@ public void topLevelExpressionTextualRepresentation() {
             treeId.set(tree.getId());
         });
 
-        // The Tank part and its attribute are not themselves expressions => ""
+        // The Tank part is not an expression => ""
         var checkTank = this.checkExpressiontTextualRepresentation(editingContextId, ExpressionSamplesProjectData.SemanticIds.TANK_ID, "");
-        var checkTankAttribute = this.checkExpressiontTextualRepresentation(editingContextId, ExpressionSamplesProjectData.SemanticIds.TANK_MAX_VOLUME_ATTRIBUTE_ID, "");
+        // The Tank's attribute is not an expression itself either, but it owns a single, non-ambiguous expression to
+        // can act as a "shortcut" to interact with id.
+        var checkTankAttribute = this.checkExpressiontTextualRepresentation(editingContextId, ExpressionSamplesProjectData.SemanticIds.TANK_MAX_VOLUME_ATTRIBUTE_ID, "100.0 * minVolume");
         // The actual attribute default value expression however should be correctly represented
         var checkTankAttributeValueExpression = this.checkExpressiontTextualRepresentation(editingContextId, ExpressionSamplesProjectData.SemanticIds.TANK_MAX_VOLUME_ATTRIBUTE_VALUE_ID,
                 "100.0 * minVolume");
 
         var checkPerformanceConcern = this.checkExpressiontTextualRepresentation(editingContextId, ExpressionSamplesProjectData.SemanticIds.PERFORMANCE_CONCERN_ID, "");
         // A ConstaintUsage *is* an Expression from the point of view of SysML's type hierarchy, but not a top-level
-        // Expression, so we expect "" here.
+        // Expression. However if it contains a single expression, it an act as a "shortcut" to it.
         var checkPerformanceConcernAssumeConstraint = this.checkExpressiontTextualRepresentation(editingContextId, ExpressionSamplesProjectData.SemanticIds.PERFORMANCE_CONCERN_ASSUME_ID, "");
-        var checkPerformanceConcernRequireConstraint = this.checkExpressiontTextualRepresentation(editingContextId, ExpressionSamplesProjectData.SemanticIds.PERFORMANCE_CONCERN_REQUIRE_ID, "");
+        var checkPerformanceConcernRequireConstraint = this.checkExpressiontTextualRepresentation(editingContextId, ExpressionSamplesProjectData.SemanticIds.PERFORMANCE_CONCERN_REQUIRE_ID,
+                "s.samplingRate >= 50.0 & s.currentValue != 0.0 | s.errorCount == 0");
         // require s.samplingRate >= 50.0 & s.currentValue != 0.0 | s.errorCount == 0
         var checkPerformanceConcernRequireConstraintExpression = this.checkExpressiontTextualRepresentation(editingContextId,
                 ExpressionSamplesProjectData.SemanticIds.PERFORMANCE_CONCERN_REQUIRE_EXPRESSION_ID, "s.samplingRate >= 50.0 & s.currentValue != 0.0 | s.errorCount == 0");

backend/application/syson-sysml-import/src/main/java/org/eclipse/syson/sysml/dto/EditExpressionInput.java

@@ -21,5 +21,5 @@
  *
  * @author pcdavid
  */
-public record EditExpressionInput(UUID id, String editingContextId, String expressionElementId, String newExpressionText) implements IInput {
+public record EditExpressionInput(UUID id, String editingContextId, String elementId, String newExpressionText) implements IInput {
 }

backend/application/syson-sysml-import/src/main/java/org/eclipse/syson/sysml/services/EditExpressionEventHandler.java

@@ -31,6 +31,7 @@
 import org.eclipse.syson.sysml.Expression;
 import org.eclipse.syson.sysml.dto.EditExpressionInput;
 import org.eclipse.syson.sysml.dto.EditExpressionSuccessPayload;
+import org.eclipse.syson.sysml.metamodel.services.MetamodelQueryElementService;
 import org.eclipse.syson.sysml.services.api.ISysMLExpressionEditor;
 import org.springframework.stereotype.Service;
 
@@ -54,6 +55,8 @@ public class EditExpressionEventHandler implements IEditingContextEventHandler {
 
     private final ISysMLExpressionEditor expressionEditor;
 
+    private final MetamodelQueryElementService metamodelQueryElementService;
+
     private final Counter counter;
 
     public EditExpressionEventHandler(IObjectSearchService objectSearchService, IIdentityService identityService, ICollaborativeMessageService messageService, ISysMLExpressionEditor expressionEditor,
@@ -62,6 +65,7 @@ public EditExpressionEventHandler(IObjectSearchService objectSearchService, IIde
         this.identityService = Objects.requireNonNull(identityService);
         this.messageService = Objects.requireNonNull(messageService);
         this.expressionEditor = Objects.requireNonNull(expressionEditor);
+        this.metamodelQueryElementService = new MetamodelQueryElementService();
         this.counter = Counter.builder(Monitoring.EVENT_HANDLER)
                 .tag(Monitoring.NAME, this.getClass().getSimpleName())
                 .register(meterRegistry);
@@ -79,13 +83,8 @@ public void handle(Sinks.One<IPayload> payloadSink, Sinks.Many<ChangeDescription
         ChangeDescription changeDescription = new ChangeDescription(ChangeKind.NOTHING, editingContext.getId(), input);
 
         if (input instanceof EditExpressionInput editExpressionInput && editingContext instanceof IEMFEditingContext emfEditingContext) {
-            Optional<Expression> optionalExpression = this.objectSearchService.getObject(editingContext, editExpressionInput.expressionElementId())
-                    .filter(Expression.class::isInstance)
-                    .map(Expression.class::cast);
-            Optional<Element> optionalParent = Optional.empty();
-            if (optionalExpression.isPresent()) {
-                optionalParent = Optional.ofNullable(optionalExpression.get().getOwner());
-            }
+            var optionalParent = this.getExpressionParent(emfEditingContext, editExpressionInput.elementId());
+            var optionalExpression = this.getExpression(emfEditingContext, editExpressionInput.elementId());
 
             if (optionalParent.isPresent() && optionalExpression.isPresent()) {
                 var result = this.expressionEditor.editExpression(emfEditingContext, optionalParent.get(), optionalExpression.get(), editExpressionInput.newExpressionText());
@@ -108,4 +107,57 @@ public void handle(Sinks.One<IPayload> payloadSink, Sinks.Many<ChangeDescription
         payloadSink.tryEmitValue(payload);
         changeDescriptionSink.tryEmitNext(changeDescription);
     }
+
+    /**
+     * Finds the {@link Expression} element to consider given the provided {@code elementId}.
+     *
+     * @param editingContext
+     *            the editing context.
+     * @param elementId
+     *            either to id of an actual {@link Expression} element, or of the parent {@link Element} of a single
+     *            {@code Expression}.
+     * @return the directly of indirectly designated {@link Expression}.
+     */
+    private Optional<Expression> getExpression(IEditingContext editingContext, String elementId) {
+        Optional<Expression> result = Optional.empty();
+        Optional<Element> optionalElement = this.objectSearchService.getObject(editingContext, elementId)
+                .filter(Element.class::isInstance)
+                .map(Element.class::cast);
+        if (optionalElement.isPresent()) {
+            Element element = optionalElement.get();
+            if (element instanceof Expression expression && this.metamodelQueryElementService.isTopLevelExpression(expression)) {
+                result = optionalElement.map(Expression.class::cast);
+            } else {
+                result = this.metamodelQueryElementService.findSingleExpressionDefinition(element);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Finds the {@link Expression} element to consider given the provided {@code elementId}.
+     *
+     * @param editingContext
+     *            the editing context.
+     * @param elementId
+     *            either to id of an actual {@link Expression} element, or of the parent {@link Element} of a single
+     *            {@code Expression}.
+     * @return the directly of indirectly designated {@link Expression}.
+     */
+    private Optional<Element> getExpressionParent(IEditingContext editingContext, String elementId) {
+        Optional<Element> result = Optional.empty();
+
+        Optional<Element> optionalElement = this.objectSearchService.getObject(editingContext, elementId)
+                .filter(Element.class::isInstance)
+                .map(Element.class::cast);
+        if (optionalElement.isPresent()) {
+            Element element = optionalElement.get();
+            if (element instanceof Expression expression && this.metamodelQueryElementService.isTopLevelExpression(expression)) {
+                result = optionalElement.map(Element::getOwner);
+            } else {
+                result = optionalElement;
+            }
+        }
+        return result;
+    }
 }

backend/application/syson-sysml-import/src/main/resources/schema/syson-import.graphqls

@@ -34,7 +34,7 @@ type CreateExpressionSuccessPayload {
 input EditExpressionInput {
   id: ID!
   editingContextId: ID!
-  expressionElementId: ID!
+  elementId: ID!
   newExpressionText: String!
 }
 

backend/views/syson-tree-explorer-view/src/main/java/org/eclipse/syson/tree/explorer/view/menu/context/SysONExplorerTreeItemContextMenuEntryProvider.java

@@ -192,7 +192,8 @@ private void addExpressionEditionEntries(List<ITreeItemContextMenuEntry> entries
             expressionEntries.add(EDIT_EXPRESSION_MENU_ENTRY_CONTRIBUTION_ID);
         } else if (this.metamodelQueryElementService.hasSingleExpressionDefinition(element)
                 && !this.metamodelQueryElementService.hasSingleExpressionDefinition(element.getOwner())) {
-            // "Delete expression" on the owner of a root Expression element
+            // "Edit expression" and "Delete expression" on the owner of a root Expression element
+            expressionEntries.add(EDIT_EXPRESSION_MENU_ENTRY_CONTRIBUTION_ID);
             expressionEntries.add(DELETE_EXPRESSION_MENU_ENTRY_CONTRIBUTION_ID);
         }
 

doc/content/modules/user-manual/pages/features/expressions.adoc

@@ -19,7 +19,7 @@ a|image::explorer-expression-internals-hidden.png[Internals hidden (default)]
 a|image::explorer-expression-internals-visible.png[Internals visible]
 |===
 
-When an `Expression` element is selected(for example from the {explorer} view), the {details}} view displays its textual representation, with a button to open the expression edition modal (see below) directly on it:
+When an `Expression` element or an `Element` which contains a single `Expression` element is selected (for example from the {explorer} view), the {details}} view displays the textual representation of the expression, with a button to open the expression edition modal (see below) directly on it:
 +
 image::expression-details.png[Expression value displayed in the _Details_ veiw, width=80%]
 
@@ -39,10 +39,10 @@ image::edit-expression-modal-error.png[Edit expression modal showing an error me
 
 == Edition
 
-To edit an already existing expression, invoke the _Edit expression_ context menu action directly on the existing expression.
+To edit an already existing expression, invoke the _Edit expression_ context menu action directly on the existing expression or on its parent element.
 The same modal as for expression creation will open, but with the current textual representation of the expression pre-filled.
 
-Edit the textual representation of the expression as required, and click on the _Update_ button to validate.
+Edit the textual representation of the expression as required, and click on the _Update_ button or hit _Ctrl-RET_ to validate.
 
 As for expression creation, the change will only be applied if there are no errors detected; otherwise the modal will display any errors (e.g. names used in the expression that can not be resolve to existing elements) so that you can fix the input.
 

doc/content/modules/user-manual/pages/release-notes/2026.7.0.adoc

@@ -54,21 +54,21 @@ In both cases, to display the `FramedConcernMembership`, deactivate the `Hide Me
 ** It is now possible to create, edit and delete _Expressions_ using their textual syntax from the _Explorer_ view.
 To _create_ an expression, invoke the _New expression_ context menu action on a compatible element (supported elements are `Attributes`, `Constraints` and `Transitions`).
 A modal will open where you can enter the textual representation of the expression to create.
-Click on the _Update_ button to validate.
+Click on the _Update_ button or hit _Ctrl-RET_ to validate.
 If the entered expression is valid, it will be created and the modal will automatically close.
 If the entered expression is _not_ valid, the modal will remain open and show the error(s) in an expandable accordion.
 Fix any error reported before clicking on _Update_ again (or canceling the operation).
 +
 image::edit-expression-modal.png[Edit expression modal, width=80%]
 image::edit-expression-modal-error.png[Edit expression modal showing an error message if the new expression is invalid, width=80%]
 +
-To _edit_ an existing expression, simply invoke the _Edit expression_ context menu action directly on the existing expression; the same modal will open but with the current textual representation of the expression pre-filled.
+To _edit_ an existing expression, simply invoke the _Edit expression_ context menu action directly on the existing expression or on its parent element; the same modal will open but with the current textual representation of the expression pre-filled.
 +
 To _delete_ an existing expression, you can simply invoke the normal _Delete_ menu item action on the expression itself or the new _Delete expression_ on its parent element.
 
 * In the _Details_ view:
 
-** When an `Expression` element is selected (for example from the _Explorer_ view), the _Details_ view displays its textual representation, with a button to open the expression edition modal (see above) directly on it:
+** When an `Expression` element or an `Element` which contains a single `Expression` element is selected (for example from the _Explorer_ view), the _Details_ view displays the textual representation of the `Expression`, with a button to open the expression edition modal (see above) directly on it:
 +
 image::expression-details.png[Expression value displayed in the _Details_ veiw, width=80%]