[2270] Add dedicated tools to diagram elements palette to create/edit/delete expressions

pcdavid · pcdavid · commit d627e9d08376 · 2026-06-16T16:01:00.000+02:00
Bug: #2270 Signed-off-by: Pierre-Charles David <pierre-charles.david@obeo.fr>
diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc
@@ -39,6 +39,7 @@ Before, the selection dialog option with selection allowed choosing between all
 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
+- https://github.com/eclipse-syson/syson/issues/2270[#2270] [diagram] Add dedicated tools to diagram elements palette to create/edit/delete expressions
 
 === New features
 
diff --git a/backend/application/syson-application-configuration/src/main/java/org/eclipse/syson/application/expressions/services/ExpressionsPaletteToolsProvider.java b/backend/application/syson-application-configuration/src/main/java/org/eclipse/syson/application/expressions/services/ExpressionsPaletteToolsProvider.java
@@ -0,0 +1,134 @@
+/*******************************************************************************
+ * Copyright (c) 2026 Obeo.
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Obeo - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.syson.application.expressions.services;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+import org.eclipse.sirius.components.collaborative.diagrams.DiagramContext;
+import org.eclipse.sirius.components.collaborative.diagrams.dto.ITool;
+import org.eclipse.sirius.components.collaborative.diagrams.dto.SingleClickOnDiagramElementTool;
+import org.eclipse.sirius.components.collaborative.diagrams.dto.ToolSection;
+import org.eclipse.sirius.components.core.api.IEditingContext;
+import org.eclipse.sirius.components.core.api.IObjectSearchService;
+import org.eclipse.sirius.components.core.api.IReadOnlyObjectPredicate;
+import org.eclipse.sirius.components.diagrams.Edge;
+import org.eclipse.sirius.components.diagrams.Node;
+import org.eclipse.sirius.components.diagrams.description.IDiagramElementDescription;
+import org.eclipse.sirius.components.emf.services.api.IEMFEditingContext;
+import org.eclipse.sirius.components.view.emf.diagram.api.IPaletteToolsProvider;
+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;
+
+/**
+ * Contribute tools to manipulate {@link Expression} to specific elements's diagram palette:
+ * <ul>
+ * <li>"New expression" on diagram elements which represent SysML elements that can contain a new
+ * {@link Expression}.</li>
+ * <li>"Edit expression" on diagram elements which represent an {@link Expression} or an element which contains a single
+ * (non-ambiguous) one.</li>
+ * <li>"Delete expression" on diagram elements which contain a single (non-ambiguous) expression (on actual expression
+ * element, the plain Delete is enough).</li>
+ * </ul>
+ *
+ * @author pcdavid
+ */
+@Service
+public class ExpressionsPaletteToolsProvider implements IPaletteToolsProvider {
+
+    private static final String NEW_EXPRESSION_TOOL_ID = "tool_new_expression";
+
+    private static final String NEW_EXPRESSION_TOOL_LABEL = "New expression";
+
+    private static final String EDIT_EXPRESSION_TOOL_ID = "tool_edit_expression";
+
+    private static final String EDIT_EXPRESSION_TOOL_LABEL = "Edit expression";
+
+    private static final String DELETE_EXPRESSION_TOOL_ID = "tool_delete_expression";
+
+    private static final String DELETE_EXPRESSION_TOOL_LABEL = "Delete expression";
+
+    private static final String EXPRESSION_TOOL_SECTION_ID = "toolSection_expression";
+
+    private static final String EXPRESSION_TOOL_SECTION_LABEL = "Expression";
+
+    private final IObjectSearchService objectSearchService;
+
+    private final IReadOnlyObjectPredicate readOnlyObjectPredicate;
+
+    private final MetamodelQueryElementService metamodelQueryElementService;
+
+    public ExpressionsPaletteToolsProvider(IObjectSearchService objectSearchService, IReadOnlyObjectPredicate readOnlyObjectPredicate) {
+        this.objectSearchService = Objects.requireNonNull(objectSearchService);
+        this.readOnlyObjectPredicate = Objects.requireNonNull(readOnlyObjectPredicate);
+        this.metamodelQueryElementService = new MetamodelQueryElementService();
+    }
+
+    @Override
+    public List<ToolSection> createExtraToolSections(IEditingContext editingContext, DiagramContext diagramContext, Object diagramElementDescription, Object diagramElement) {
+        var tools = new ArrayList<ITool>();
+
+        var optionalTargetObjectId = this.getTargetObjectId(diagramElement);
+
+        if (optionalTargetObjectId.isPresent() && diagramElementDescription instanceof IDiagramElementDescription nodeDescription) {
+            var semanticObject = this.objectSearchService.getObject(editingContext, optionalTargetObjectId.get());
+            if (semanticObject.isPresent() && semanticObject.get() instanceof Element element) {
+                if (editingContext instanceof IEMFEditingContext emfEditingContext && this.canHaveNewExpression(emfEditingContext, element)) {
+                    tools.add(new SingleClickOnDiagramElementTool(NEW_EXPRESSION_TOOL_ID, NEW_EXPRESSION_TOOL_LABEL, List.of(), List.of(nodeDescription), "", false, false, List.of()));
+                }
+                if (this.canEditExpression(element)) {
+                    tools.add(new SingleClickOnDiagramElementTool(EDIT_EXPRESSION_TOOL_ID, EDIT_EXPRESSION_TOOL_LABEL, List.of(), List.of(nodeDescription), "", false, false, List.of()));
+                    if (!this.metamodelQueryElementService.isTopLevelExpression(element)) {
+                        tools.add(new SingleClickOnDiagramElementTool(DELETE_EXPRESSION_TOOL_ID, DELETE_EXPRESSION_TOOL_LABEL, List.of(), List.of(nodeDescription), "", false, false, List.of()));
+                    }
+                }
+            }
+        }
+
+        if (!tools.isEmpty()) {
+            return List.of(new ToolSection(EXPRESSION_TOOL_SECTION_ID, EXPRESSION_TOOL_SECTION_LABEL, List.of(), tools));
+        } else {
+            return List.of();
+        }
+    }
+
+    private Optional<String> getTargetObjectId(Object diagramElement) {
+        Optional<String> result = Optional.empty();
+        if (diagramElement instanceof Node node) {
+            result = Optional.of(node.getTargetObjectId());
+        } else if (diagramElement instanceof Edge edge) {
+            result = Optional.of(edge.getTargetObjectId());
+        }
+        return result;
+    }
+
+    private boolean canHaveNewExpression(IEMFEditingContext editingContext, Element element) {
+        return !this.readOnlyObjectPredicate.test(element) && this.metamodelQueryElementService.canContainExpressionDefinition(element)
+                && !this.metamodelQueryElementService.hasSingleExpressionDefinition(element);
+    }
+
+    private boolean canEditExpression(Element element) {
+        return this.metamodelQueryElementService.isTopLevelExpression(element) || (this.metamodelQueryElementService.hasSingleExpressionDefinition(element)
+                && !this.metamodelQueryElementService.hasSingleExpressionDefinition(element.getOwner()));
+    }
+
+    @Override
+    public List<ITool> createQuickAccessTools(IEditingContext editingContext, DiagramContext diagramContext, Object diagramElementDescription, Object diagramElement) {
+        return List.of();
+    }
+
+}
diff --git a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/interconnection/view/IVInterconnectionCompartmentToolsTests.java b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/interconnection/view/IVInterconnectionCompartmentToolsTests.java
@@ -113,8 +113,8 @@ public void testQueryPaletteAndExecuteTools() {
             assertThat(quickToolsLabels).hasSize(4);
             assertThat(quickToolsLabels).containsSequence("Pin", "Adjust size", "Fade", "Hide");
             List<String> paletteEntriesLabels = JsonPath.read(result.data(), "$.data.viewer.editingContext.representation.description.palette.paletteEntries[*].label");
-            assertThat(paletteEntriesLabels).hasSize(5);
-            assertThat(paletteEntriesLabels).containsSequence("Requirements", "Structure", "Show/Hide", "Related Elements", "Edit");
+            assertThat(paletteEntriesLabels).hasSize(6);
+            assertThat(paletteEntriesLabels).containsSequence("Requirements", "Structure", "Show/Hide", "Related Elements", "Edit", "Expression");
 
             List<String> paletteRequirementsSectionToolsLabels = JsonPath.read(result.data(), "$.data.viewer.editingContext.representation.description.palette.paletteEntries[0].tools[*].label");
             assertThat(paletteRequirementsSectionToolsLabels).hasSize(1);
diff --git a/backend/services/syson-diagram-services/src/main/java/org/eclipse/syson/diagram/services/DiagramQueryLabelService.java b/backend/services/syson-diagram-services/src/main/java/org/eclipse/syson/diagram/services/DiagramQueryLabelService.java
@@ -58,6 +58,7 @@
 import org.eclipse.syson.sysml.Usage;
 import org.eclipse.syson.sysml.VariantMembership;
 import org.eclipse.syson.sysml.metamodel.helper.LabelConstants;
+import org.eclipse.syson.sysml.metamodel.services.MetamodelQueryElementService;
 import org.eclipse.syson.sysml.metamodel.services.textual.SysMLElementSerializer;
 import org.eclipse.syson.sysml.metamodel.services.textual.SysMLSerializingOptions;
 import org.eclipse.syson.sysml.metamodel.services.textual.utils.Appender;
@@ -93,6 +94,8 @@ public class DiagramQueryLabelService implements IDiagramLabelService {
 
     private final Logger logger = LoggerFactory.getLogger(DiagramQueryLabelService.class);
 
+    private final MetamodelQueryElementService metamodelQueryElementService = new MetamodelQueryElementService();
+
     @Override
     public String getIdentificationLabel(Element element) {
         StringBuilder label = new StringBuilder();
@@ -508,6 +511,22 @@ private String getCompartmentItemStringRepresentation(Usage usage, boolean direc
         return label.toString();
     }
 
+    /**
+     * The default begin label for edges.
+     *
+     * @param element
+     *            the element to get the edge label from
+     * @return the begin edge label
+     */
+    public String getBeginEdgeLabel(Element element) {
+        var optionalExpression = this.metamodelQueryElementService.findSingleExpressionDefinition(element);
+        if (optionalExpression.isPresent()) {
+            var expression = optionalExpression.get();
+            return LabelConstants.OPEN_BRACKET + this.metamodelQueryElementService.getExpressionTextualRepresentation(expression) + LabelConstants.CLOSE_BRACKET;
+        }
+        return null;
+    }
+
     /**
      * The default label for edges.
      *
diff --git a/backend/services/syson-diagram-services/src/main/java/org/eclipse/syson/diagram/services/aql/DiagramQueryAQLService.java b/backend/services/syson-diagram-services/src/main/java/org/eclipse/syson/diagram/services/aql/DiagramQueryAQLService.java
@@ -137,6 +137,13 @@ public String getDependencyLabel(Dependency dependency) {
         return this.diagramQueryLabelService.getDependencyLabel(dependency);
     }
 
+    /**
+     * {@link DiagramQueryLabelService#getBeginEdgeLabel(Element)}.
+     */
+    public String getBeginEdgeLabel(Element element) {
+        return this.diagramQueryLabelService.getBeginEdgeLabel(element);
+    }
+
     /**
      * {@link DiagramQueryLabelService#getEdgeLabel(Element)}.
      */
diff --git a/backend/views/syson-diagram-common-view/src/main/java/org/eclipse/syson/diagram/common/view/edges/AbstractSuccessionEdgeDescriptionProvider.java b/backend/views/syson-diagram-common-view/src/main/java/org/eclipse/syson/diagram/common/view/edges/AbstractSuccessionEdgeDescriptionProvider.java
@@ -78,6 +78,7 @@ public EdgeDescription create() {
                 .domainType(domainType)
                 .preconditionExpression("aql:graphicalEdgeSource.isInSameGraphicalContainer(graphicalEdgeTarget,cache) and not self.getOwningElement().oclIsKindOf(sysml::TransitionUsage)")
                 .isDomainBasedEdge(true)
+                .beginLabelExpression(ServiceMethod.of0(DiagramQueryAQLService::getBeginEdgeLabel).aqlSelf())
                 .centerLabelExpression(ServiceMethod.of0(DiagramQueryAQLService::getEdgeLabel).aqlSelf())
                 .name(this.descriptionNameGenerator.getEdgeName(SysmlPackage.eINSTANCE.getSuccession()))
                 .semanticCandidatesExpression(ServiceMethod.of1(UtilService::getAllReachable).aqlSelf(domainType))
diff --git a/backend/views/syson-tree-explorer-view/src/main/java/org/eclipse/syson/tree/explorer/view/menu/context/SysONExplorerTreeItemContextMenuEntryProvider.java b/backend/views/syson-tree-explorer-view/src/main/java/org/eclipse/syson/tree/explorer/view/menu/context/SysONExplorerTreeItemContextMenuEntryProvider.java
@@ -148,7 +148,7 @@ private List<ITreeItemContextMenuEntry> getObjectContextMenuEntries(IEMFEditingC
                     entries.add(new SingleClickTreeItemContextMenuEntry(ExplorerTreeItemContextMenuEntryProvider.NEW_REPRESENTATION, "", List.of(), false, List.of()));
                 }
                 entries.add(new SingleClickTreeItemContextMenuEntry(NEW_OBJECTS_FROM_TEXT_MENU_ENTRY_CONTRIBUTION_ID, "", List.of(), false, List.of()));
-                if (this.canHaveNewExpression(editingContext, treeItem.getId(), object)) {
+                if (this.canHaveNewExpression(editingContext, object)) {
                     entries.add(new SingleClickTreeItemContextMenuEntry(CREATE_EXPRESSION_MENU_ENTRY_CONTRIBUTION_ID, "", List.of(), false, List.of()));
                 }
 
@@ -178,7 +178,7 @@ private boolean canHaveNewRepresentation(IEMFEditingContext editingContext, Stri
         return result;
     }
 
-    private boolean canHaveNewExpression(IEMFEditingContext editingContext, String treeItemId, EObject object) {
+    private boolean canHaveNewExpression(IEMFEditingContext editingContext, EObject object) {
         return !this.readOnlyObjectPredicate.test(object) && object instanceof Element element && this.metamodelQueryElementService.canContainExpressionDefinition(element)
                 && !this.metamodelQueryElementService.hasSingleExpressionDefinition(element);
     }
diff --git a/doc/content/modules/user-manual/assets/images/action-flow-guard-labels.png b/doc/content/modules/user-manual/assets/images/action-flow-guard-labels.png
diff --git a/doc/content/modules/user-manual/assets/images/expression-palette-section.png b/doc/content/modules/user-manual/assets/images/expression-palette-section.png
diff --git a/doc/content/modules/user-manual/pages/features/expressions.adoc b/doc/content/modules/user-manual/pages/features/expressions.adoc
@@ -25,7 +25,9 @@ image::expression-details.png[Expression value displayed in the _Details_ veiw,
 
 == Creation
 
-To _create_ an expression, invoke the _New expression_ context menu action on a compatible element (supported elements are `Attributes`, `Constraints` and `Transitions`).
+To _create_ an expression, invoke the _New expression_ action on a compatible element (supported elements are `Attributes`, `Constraints` and `Transitions`).
+In the {explorer} view, this is available in the element's context menu.
+In a _Diagram_, it is avilable in the _Expression_ section of the element's palette (if applicable).
 
 A modal will open where you can enter the textual representation of the expression to create.
 Click on the _Update_ button to validate.
@@ -39,7 +41,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 or on its parent element.
+To edit an already existing expression, invoke the _Edit expression_ action directly on the existing expression or on its parent element.
+In the {explorer} view, this is available in the element's context menu.
+In a _Diagram_, it is avilable in the _Expression_ section of the element's palette (if applicable).
+
 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 or hit _Ctrl-RET_ to validate.
diff --git a/doc/content/modules/user-manual/pages/release-notes/2026.7.0.adoc b/doc/content/modules/user-manual/pages/release-notes/2026.7.0.adoc
@@ -100,6 +100,16 @@ Now, the label dynamically adapts based on whether the `ConcernUsage` or `Constr
 ** Update the choice of _timeslice_ and _snapshot_ elements that can be created in the selection dialog of tools creating _timeslice_ and _snapshot_ elements.
 Before, the selection dialog allowed choosing between all _timeslice_ and _snapshot_ types.
 Now, the choice is restricted to the _timeslice_ or _snapshot_ type that matches the graphical node type on which the tool is applied.
+** It is now possible to create, edit and delete _Expressions_ using their textual syntax from the a diagram.
+To _create_ an expression, invoke the _New expression_ action in the _Expression_ palette section of a compatible element (supported elements are `Attributes`, `Constraints` and `Transitions`).
+The same modal as described above when invoked from the _Explorer_ or _Details_ view will open where you can enter the textual representation of the expression to create.
+Editing and deleting an _Expression_ is also available on compatible diagram elements with the corresponding actions in their _Expressions_ palette section.
+The behavior is the same when invoking the equivalen action from the _Explorer_ or _Details_ view.
++
+image::expression-palette-section.png[Expression palette tool section on an `Attribute` in a diagram, width=80%]
+** In an _action flow_ compartment, `Succession` edges which have a guard now display the guard condition `Expression` as a _begin label_:
++
+image::action-flow-guard-labels.png[Succession edges with visible guard expressions, width=80%]
 
 == Technical details
 
diff --git a/frontend/syson-components/src/extensions/expressions/DeleteExpressionDiagramToolOverriddenContribution.tsx b/frontend/syson-components/src/extensions/expressions/DeleteExpressionDiagramToolOverriddenContribution.tsx
@@ -0,0 +1,98 @@
+/*******************************************************************************
+ * Copyright (c) 2026 Obeo.
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Obeo - initial API and implementation
+ *******************************************************************************/
+import { useDeletionConfirmationDialog } from '@eclipse-sirius/sirius-components-core';
+import {
+  DiagramContext,
+  DiagramContextValue,
+  EdgeData,
+  NodeData,
+  useDiagramPalette,
+} from '@eclipse-sirius/sirius-components-diagrams';
+import { PaletteToolContributionComponentProps } from '@eclipse-sirius/sirius-components-palette';
+import DeleteIcon from '@mui/icons-material/Delete';
+import ListItemButton from '@mui/material/ListItemButton';
+import ListItemIcon from '@mui/material/ListItemIcon';
+import ListItemText from '@mui/material/ListItemText';
+import { Edge, InternalNode, Node, useStoreApi } from '@xyflow/react';
+import { useContext } from 'react';
+import { makeStyles } from 'tss-react/mui';
+import { useDeleteExpression } from './useDeleteExpression';
+
+const useStyle = makeStyles()((theme) => ({
+  listItemText: {
+    '& .MuiListItemText-primary': {
+      whiteSpace: 'nowrap',
+      overflow: 'hidden',
+      textOverflow: 'ellipsis',
+    },
+  },
+  listItemButton: {
+    paddingTop: 0,
+    paddingBottom: 0,
+  },
+  listItemIcon: {
+    minWidth: 0,
+    marginRight: theme.spacing(2),
+  },
+}));
+
+export const DeleteExpressionDiagramToolOverriddenContribution = ({
+  representationElementIds,
+}: PaletteToolContributionComponentProps) => {
+  const { classes } = useStyle();
+  const { editingContextId, readOnly } = useContext<DiagramContextValue>(DiagramContext);
+  const store = useStoreApi<Node<NodeData>, Edge<EdgeData>>();
+  const { deleteExpression } = useDeleteExpression();
+  const { showDeletionConfirmation } = useDeletionConfirmationDialog();
+  const { hideDiagramPalette } = useDiagramPalette();
+
+  let elementId = '';
+  const targetedNodes: InternalNode<Node<NodeData>>[] = representationElementIds
+    .map((elementId) => store.getState().nodeLookup.get(elementId))
+    .filter((element): element is InternalNode<Node<NodeData>> => !!element);
+
+  if (targetedNodes.length === 1 && targetedNodes[0] !== null) {
+    elementId = targetedNodes[0]?.data.targetObjectId || '';
+  } else {
+    const targetedEdges: Edge<EdgeData>[] = representationElementIds
+      .map((elementId) => store.getState().edgeLookup.get(elementId))
+      .filter((element): element is Edge<EdgeData> => !!element);
+    const targetedEdge = targetedEdges[0];
+    if (targetedEdges.length === 1 && targetedEdge) {
+      elementId = targetedEdge.data?.targetObjectId || '';
+    } else {
+      return null;
+    }
+  }
+
+  const handleDeleteExpression = () => {
+    showDeletionConfirmation(() => {
+      deleteExpression(editingContextId, elementId);
+      hideDiagramPalette();
+    });
+  };
+
+  return (
+    <ListItemButton
+      key="overridden_tool_delete_expression"
+      data-testid="overridden_tool_delete_expression"
+      onClick={handleDeleteExpression}
+      disabled={readOnly}
+      className={classes.listItemButton}>
+      <ListItemIcon className={classes.listItemIcon}>
+        <DeleteIcon fontSize="small" />
+      </ListItemIcon>
+      <ListItemText primary={'Delete expression'} className={classes.listItemText} />
+    </ListItemButton>
+  );
+};
diff --git a/frontend/syson-components/src/extensions/expressions/EditExpressionDiagramToolOverriddenContribution.tsx b/frontend/syson-components/src/extensions/expressions/EditExpressionDiagramToolOverriddenContribution.tsx
diff --git a/frontend/syson-components/src/extensions/expressions/NewExpressionDiagramToolOverriddenContribution.tsx b/frontend/syson-components/src/extensions/expressions/NewExpressionDiagramToolOverriddenContribution.tsx
diff --git a/frontend/syson-components/src/extensions/registry/SysONExtensionRegistry.tsx b/frontend/syson-components/src/extensions/registry/SysONExtensionRegistry.tsx

Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ private List<ITreeItemContextMenuEntry> getObjectContextMenuEntries(IEMFEditingC`
`148`	`148`	`entries.add(new SingleClickTreeItemContextMenuEntry(ExplorerTreeItemContextMenuEntryProvider.NEW_REPRESENTATION, "", List.of(), false, List.of()));`
`149`	`149`	`}`
`150`	`150`	`entries.add(new SingleClickTreeItemContextMenuEntry(NEW_OBJECTS_FROM_TEXT_MENU_ENTRY_CONTRIBUTION_ID, "", List.of(), false, List.of()));`
`151`		`- if (this.canHaveNewExpression(editingContext, treeItem.getId(), object)) {`
	`151`	`+ if (this.canHaveNewExpression(editingContext, object)) {`
`152`	`152`	`entries.add(new SingleClickTreeItemContextMenuEntry(CREATE_EXPRESSION_MENU_ENTRY_CONTRIBUTION_ID, "", List.of(), false, List.of()));`
`153`	`153`	`}`
`154`	`154`
`@@ -178,7 +178,7 @@ private boolean canHaveNewRepresentation(IEMFEditingContext editingContext, Stri`
`178`	`178`	`return result;`
`179`	`179`	`}`
`180`	`180`
`181`		`- private boolean canHaveNewExpression(IEMFEditingContext editingContext, String treeItemId, EObject object) {`
	`181`	`+ private boolean canHaveNewExpression(IEMFEditingContext editingContext, EObject object) {`
`182`	`182`	`return !this.readOnlyObjectPredicate.test(object) && object instanceof Element element && this.metamodelQueryElementService.canContainExpressionDefinition(element)`
`183`	`183`	`&& !this.metamodelQueryElementService.hasSingleExpressionDefinition(element);`
`184`	`184`	`}`