diff options
| author | Ed Willink | 2019-11-19 19:27:10 +0000 |
|---|---|---|
| committer | Ed Willink | 2019-12-03 17:23:56 +0000 |
| commit | a4c9d1f9483994ce0e84883e6e6a460b2a9cb4e8 (patch) | |
| tree | 1d30ee67c3b24989dda0b7d440005430920b410f | |
| parent | 9c7fff8a8c1cbd349d68bbcd1af42ce19773759c (diff) | |
| download | org.eclipse.qvtd-a4c9d1f9483994ce0e84883e6e6a460b2a9cb4e8.tar.gz org.eclipse.qvtd-a4c9d1f9483994ce0e84883e6e6a460b2a9cb4e8.tar.xz org.eclipse.qvtd-a4c9d1f9483994ce0e84883e6e6a460b2a9cb4e8.zip | |
[553706] Introduce InitUtility valid at Node/Edge initialization
78 files changed, 1330 insertions, 1520 deletions
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/AbstractScheduleManager.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/AbstractScheduleManager.java index b1fae4c8f..42eefe9e1 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/AbstractScheduleManager.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/AbstractScheduleManager.java @@ -88,6 +88,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.ScheduleModel; import org.eclipse.qvtd.pivot.qvtschedule.utilities.AbstractToGraphVisitor; import org.eclipse.qvtd.pivot.qvtschedule.utilities.DomainUsage; import org.eclipse.qvtd.pivot.qvtschedule.utilities.Graphable; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; import org.eclipse.qvtd.pivot.qvtschedule.utilities.ToGraphPartitionVisitor; import org.eclipse.qvtd.pivot.qvtschedule.utilities.ToGraphVisitor; @@ -422,14 +423,14 @@ public abstract class AbstractScheduleManager implements ScheduleManager TypedModel typedModel = getDomainUsage(expression).getTypedModel(expression); assert typedModel != null; ClassDatum classDatum = getClassDatum(typedModel, type); - Node parameterNode = regionHelper.createOperationParameterNode(name, classDatum); + Node parameterNode = regionHelper.createOperationParameterNode(InitUtility.getRequiredInitUtility(variable), name, classDatum); // addVariableNode(variable, parameterNode); regionHelper.getRegion().addHeadNode(parameterNode); return parameterNode; } - private @NonNull Node createOperationParameterNode(@NonNull OperationRegionHelper regionHelper, @NonNull ClassDatum classDatum, @NonNull String name) { - Node parameterNode = regionHelper.createOperationParameterNode(name, classDatum); + private @NonNull Node createOperationParameterNode(@NonNull OperationRegionHelper regionHelper, @NonNull InitUtility initUtility, @NonNull ClassDatum classDatum, @NonNull String name) { + Node parameterNode = regionHelper.createOperationParameterNode(initUtility, name, classDatum); // addVariableNode(variable, parameterNode); regionHelper.getRegion().addHeadNode(parameterNode); return parameterNode; @@ -453,9 +454,10 @@ public abstract class AbstractScheduleManager implements ScheduleManager Node dependencyNode; dependencyNode = selfNode; // - Node resultNode = regionHelper.createStepNode("result", operationCallExp, dependencyNode, false); // FIXME do not use a MappingNode + InitUtility initUtility = InitUtility.getRequiredInitUtility(operationCallExp); + Node resultNode = regionHelper.createStepNode(initUtility, "result", operationCallExp, dependencyNode); // FIXME do not use a MappingNode operationRegion.setResultNode(resultNode); - regionHelper.createEqualsEdge(dependencyNode, resultNode); + regionHelper.createEqualsEdge(initUtility, dependencyNode, resultNode); // List<Variable> ownedParameters = specification.getOwnedParameters(); List<OCLExpression> ownedArguments = operationCallExp.getOwnedArguments(); @@ -509,7 +511,7 @@ public abstract class AbstractScheduleManager implements ScheduleManager dependencyNode2 = classDatum2node.get(classDatum); if (dependencyNode2 == null) { assert !"OclVoid".equals(stepType.getName()); - dependencyNode2 = createOperationParameterNode(regionHelper, classDatum, "extra2_" + stepType.getName()); + dependencyNode2 = createOperationParameterNode(regionHelper, InitUtility.NON_NULL_MATCHED, classDatum, "extra2_" + stepType.getName()); classDatum2node.put(classDatum, dependencyNode2); operationRegion.addDependencyNode(dependencyNode2); } @@ -532,9 +534,9 @@ public abstract class AbstractScheduleManager implements ScheduleManager Type elementType = PivotUtil.getElementType((CollectionType)primaryClass); TypedModel typedModel2 = QVTscheduleUtil.getTypedModel(classDatum); ClassDatum elementClassDatum = scheduleManager.getClassDatum(typedModel2, (org.eclipse.ocl.pivot.Class) elementType); - Node elementNode = regionHelper.createOperationElementNode(operationName, elementClassDatum, dependencyNode2); + Node elementNode = regionHelper.createOperationElementNode(InitUtility.NON_NULL_MATCHED, operationName, elementClassDatum, dependencyNode2); //(region, name, typedElement, argNodes)Node(region, name, callExp, sourceNode)Node(this, name, iterateProperty, dependencyNode2); - regionHelper.createNavigationEdge(dependencyNode2, iterateProperty, elementNode, false); + regionHelper.createNavigationEdge(InitUtility.NON_NULL_MATCHED, dependencyNode2, iterateProperty, elementNode, false); dependencyNode2 = elementNode; } // assert !dependencyNode2.isMatched(); @@ -544,12 +546,12 @@ public abstract class AbstractScheduleManager implements ScheduleManager if (name == null) { name = QVTscheduleUtil.getName(PivotUtil.getReferredProperty((NavigationCallExp)callExp)); } - nextNode = regionHelper.createDataTypeNode(name, dependencyNode2, (NavigationCallExp)callExp); + nextNode = regionHelper.createDataTypeNode(InitUtility.getRequiredInitUtility(callExp), name, dependencyNode2, (NavigationCallExp)callExp); } else { - nextNode = regionHelper.createDataTypeNode(dependencyNode2, property); + nextNode = regionHelper.createDataTypeNode(InitUtility.getRequiredInitUtility(property), dependencyNode2, property); } - regionHelper.createNavigationEdge(dependencyNode2, property, nextNode, false); + regionHelper.createNavigationEdge(InitUtility.getRequiredInitUtility(property), dependencyNode2, property, nextNode, false); dependencyNode2 = nextNode; } } @@ -560,7 +562,6 @@ public abstract class AbstractScheduleManager implements ScheduleManager } } // - UtilityAnalysis.assignUtilities(scheduleManager, operationRegion); operationRegion.toGraph(new DOTStringBuilder()); operationRegion.toGraph(new GraphMLStringBuilder()); return operationRegion; diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/ExpressionSynthesizer.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/ExpressionSynthesizer.java index b6faa6c48..07d2e0234 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/ExpressionSynthesizer.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/ExpressionSynthesizer.java @@ -76,8 +76,8 @@ import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.CollectionLiteralNode; import org.eclipse.qvtd.pivot.qvtschedule.Edge; import org.eclipse.qvtd.pivot.qvtschedule.EnumLiteralNode; +import org.eclipse.qvtd.pivot.qvtschedule.IfNode; import org.eclipse.qvtd.pivot.qvtschedule.MapLiteralNode; -import org.eclipse.qvtd.pivot.qvtschedule.MappingNode; import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge; import org.eclipse.qvtd.pivot.qvtschedule.NavigationEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; @@ -89,26 +89,22 @@ import org.eclipse.qvtd.pivot.qvtschedule.ShadowNode; import org.eclipse.qvtd.pivot.qvtschedule.TupleLiteralNode; import org.eclipse.qvtd.pivot.qvtschedule.TypeLiteralNode; import org.eclipse.qvtd.pivot.qvtschedule.impl.RuleRegionImpl; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; import org.eclipse.qvtd.runtime.utilities.QVTruntimeLibraryHelper; public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisitor<@Nullable Node, @NonNull RuleAnalysis> { - // private static final @NonNull String @NonNull [] ifArgNames = new @NonNull String[]{QVTscheduleConstants.IF_CONDITION_NAME, QVTscheduleConstants.IF_THEN_NAME, QVTscheduleConstants.IF_ELSE_NAME}; - // private static final @NonNull String @NonNull [] mapArgNames = new @NonNull String[]{"«key»", "«value»"}; - // private static final @NonNull String @NonNull [] nullArgNames = new @NonNull String[]{QVTscheduleConstants.EQUALS_NAME}; - // private static final @NonNull String @NonNull [] rangeArgNames = new @NonNull String[]{"«first»", "«last»"}; - // private static final @NonNull String @NonNull [] srcArgNames = new @NonNull String[]{"«source»", "«arg»"}; - - protected final boolean isUnconditional; + protected final @NonNull InitUtility resultUtility; protected final @NonNull ScheduleManager scheduleManager; protected final @NonNull EnvironmentFactory environmentFactory; protected final @NonNull QVTbaseHelper helper; protected final @NonNull StandardLibraryHelper standardLibraryHelper; protected final @NonNull QVTruntimeLibraryHelper qvtbaseLibraryHelper; - protected final @NonNull ExpressionSynthesizer unconditionalExpressionSynthesizer; - private /*@LazyNonNull*/ ExpressionSynthesizer conditionalExpressionSynthesizer = null; - // private /*@LazyNonNull*/ OperationDependencyAnalysis operationDependencyAnalysis; + protected final @NonNull ExpressionSynthesizer nonNullMatchedExpressionSynthesizer; + private /*@LazyNonNull*/ ExpressionSynthesizer nullableMatchedExpressionSynthesizer = null; + private /*@LazyNonNull*/ ExpressionSynthesizer nullableConditionalExpressionSynthesizer = null; + private /*@LazyNonNull*/ ExpressionSynthesizer nonNullConditionalExpressionSynthesizer = null; /** * Map from the non-trivial side of an "=" expression to the known node for a variable on the other side. This avoids the need to create a redundant @@ -117,30 +113,52 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi private @Nullable Map<@NonNull OCLExpression, @NonNull Node> expression2knownNode; /** - * Construct the unconditional ExpressionSynthesizer (unconditionalExpressionSynthesizer == null), or + * Construct the nullable unconditional ExpressionSynthesizer (unconditionalExpressionSynthesizer == null), or * conditionalExpressionSynthesizer (unconditionalExpressionSynthesizer != null) for context. */ - protected ExpressionSynthesizer(@NonNull RuleAnalysis context, @Nullable ExpressionSynthesizer unconditionalExpressionSynthesizer) { + protected ExpressionSynthesizer(@NonNull RuleAnalysis context, @Nullable ExpressionSynthesizer unconditionalExpressionSynthesizer, @NonNull InitUtility resultUtility) { super(context); - this.isUnconditional = unconditionalExpressionSynthesizer == null; - this.unconditionalExpressionSynthesizer = unconditionalExpressionSynthesizer != null ? unconditionalExpressionSynthesizer : this; + this.resultUtility = resultUtility; + switch (resultUtility) { + case NON_NULL_MATCHED: { + assert unconditionalExpressionSynthesizer == null; + break; + } + case NULLABLE_MATCHED: { + assert unconditionalExpressionSynthesizer != null; + break; + } + case NON_NULL_CONDITIONAL: { + assert unconditionalExpressionSynthesizer != null; + break; + } + case NULLABLE_CONDITIONAL: { + assert unconditionalExpressionSynthesizer != null; + break; + } + default: + throw new UnsupportedOperationException(); + } + this.nonNullMatchedExpressionSynthesizer = unconditionalExpressionSynthesizer != null ? unconditionalExpressionSynthesizer : this; this.scheduleManager = context.getScheduleManager(); this.environmentFactory = scheduleManager.getEnvironmentFactory(); this.helper = new QVTbaseHelper(environmentFactory); this.standardLibraryHelper = scheduleManager.getStandardLibraryHelper(); this.qvtbaseLibraryHelper = scheduleManager.getQVTruntimeLibraryHelper(); - // this.operationDependencyAnalysis = getOperationDependencyAnalysis(); } protected @NonNull Node createBooleanLiteralNode(boolean booleanValue, @NonNull BooleanLiteralExp booleanLiteralExp) { - return context.createBooleanLiteralNode(isUnconditional(), booleanValue, booleanLiteralExp); + InitUtility utility = getRequiredInitUtility(booleanLiteralExp); + return context.createBooleanLiteralNode(utility, booleanValue, booleanLiteralExp); } public @NonNull CastEdge createCastEdge(@NonNull Node sourceNode, @NonNull ClassDatum classDatum, @NonNull Node castNode) { - return context.createCastEdge(sourceNode, classDatum, castNode); + InitUtility utility = getRequiredInitUtility(castNode); + return context.createCastEdge(utility, sourceNode, classDatum, castNode); } protected @NonNull Node createCollectionLiteral(@NonNull CollectionLiteralExp collectionLiteralExp, @NonNull CollectionLiteralPart [] collectionParts, @NonNull Node @NonNull [] partNodes) { + InitUtility utility = getRequiredInitUtility(collectionLiteralExp); Operation collectionOperation = qvtbaseLibraryHelper.getCollectionOperation(); assert collectionParts.length == partNodes.length; Node reusedNode = findOperationNode(collectionOperation, partNodes); @@ -152,14 +170,16 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi if (nodeName == null) { nodeName = QVTbaseUtil.getName(collectionOperation); } - CollectionLiteralNode collectionLiteralNode = context.createCollectionLiteralNode(isUnconditional(), nodeName, collectionLiteralExp, partNodes); + CollectionLiteralNode collectionLiteralNode = context.createCollectionLiteralNode(utility, nodeName, collectionLiteralExp, partNodes); for (int i = 0; i < collectionParts.length; i++) { - context.createCollectionPartEdge(partNodes[i], collectionParts[i], collectionLiteralNode); + CollectionLiteralPart collectionPart = collectionParts[i]; + InitUtility partInitUtility = getRequiredInitUtility(collectionPart); + context.createCollectionPartEdge(partInitUtility, partNodes[i], collectionPart, collectionLiteralNode); } return collectionLiteralNode; } - protected @NonNull Node createCollectionRange(@NonNull CollectionRange collectionRange, @NonNull Node firstNode, @NonNull Node lastNode) { + protected @NonNull Node createCollectionRange(@NonNull InitUtility utility, @NonNull CollectionRange collectionRange, @NonNull Node firstNode, @NonNull Node lastNode) { Operation rangeOperation = qvtbaseLibraryHelper.getRangeOperation(); @NonNull Node[] sourceAndArgumentNodes = new @NonNull Node[] { firstNode, lastNode }; Node reusedNode = findOperationNode(rangeOperation, sourceAndArgumentNodes); @@ -171,7 +191,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi if (nodeName == null) { nodeName = QVTbaseUtil.getName(rangeOperation); } - Node operationNode = context.createCollectionRangeNode(isUnconditional(), nodeName, collectionRange, sourceAndArgumentNodes); + Node operationNode = context.createCollectionRangeNode(utility, nodeName, collectionRange, sourceAndArgumentNodes); Parameter firstParameter = qvtbaseLibraryHelper.getRangeFirstParameter(); Parameter lastParameter = qvtbaseLibraryHelper.getRangeLastParameter(); createOperationParameterEdge(firstNode, firstParameter, -1, operationNode); @@ -179,22 +199,22 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi return operationNode; } - protected abstract @NonNull ExpressionSynthesizer createConditionalExpressionSynthesizer(); - protected @NonNull Node createDataTypeNode(@NonNull String name, @NonNull Node sourceNode, @NonNull NavigationCallExp navigationCallExp) { - return context.createDataTypeNode(name, sourceNode, navigationCallExp); + InitUtility utility = getRequiredInitUtility(navigationCallExp); + return context.createDataTypeNode(utility, name, sourceNode, navigationCallExp); } protected @NonNull Edge createDependencyEdge(@NonNull Node sourceNode, @NonNull String name, @NonNull Node targetNode) { - return context.createDependencyEdge(sourceNode, name, targetNode); + return context.createDependencyEdge(InitUtility.DEPENDENCY, sourceNode, name, targetNode); } protected @NonNull Node createDependencyNode(@NonNull String name, @NonNull ClassDatum classDatum) { - return context.createDependencyNode(name, classDatum); + return context.createDependencyNode(InitUtility.DEPENDENCY, name, classDatum); } protected @NonNull EnumLiteralNode createEnumLiteralNode(@NonNull EnumerationLiteral enumValue, @NonNull EnumLiteralExp enumLiteralExp) { - return context.createEnumLiteralNode(isUnconditional(), enumValue, enumLiteralExp); + InitUtility utility = getRequiredInitUtility(enumLiteralExp); + return context.createEnumLiteralNode(utility, enumValue, enumLiteralExp); } protected @NonNull Node createErrorNode(@NonNull String name, @NonNull ClassDatum classDatum) { @@ -202,47 +222,33 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi } protected @NonNull Edge createEqualsEdge(@NonNull Node sourceNode, @NonNull Node targetNode) { - return context.createEqualsEdge(sourceNode, targetNode); + return context.createEqualsEdge(resultUtility, sourceNode, targetNode); } - protected @NonNull Node createIf(@NonNull IfExp ifExp, @NonNull Node selfNode, @NonNull Node thenNode, @NonNull Node elseNode) { - Operation ifOperation = qvtbaseLibraryHelper.getIfOperation(); - @NonNull Node [] sourceAndArgumentNodes = new @NonNull Node[] { selfNode, thenNode, elseNode }; - Node reusedNode = findOperationNode(ifOperation, sourceAndArgumentNodes); - if (reusedNode != null) { - // reusedNode.addTypedElement(ifExp); - return reusedNode; - } - String nodeName = CompilerUtil.recoverVariableName(ifExp); - if (nodeName == null) { - nodeName = QVTbaseUtil.getName(ifOperation); - } - // Node operationNode = nestedAnalyzer.createOperationNode(nodeName, typedElement, sourceAndArgumentNodes); - Node operationNode = context.createIfNode(isUnconditional(), nodeName, ifExp, sourceAndArgumentNodes); - // org.eclipse.ocl.pivot.Class selfType = standardLibraryHelper.getStandardLibrary().getBooleanType(); - Parameter conditionParameter = qvtbaseLibraryHelper.getIfConditionParameter(); - Parameter thenParameter = qvtbaseLibraryHelper.getIfThenParameter(); - Parameter elseParameter = qvtbaseLibraryHelper.getIfElseParameter(); - // createOperationSelfEdge(selfNode, selfType, operationNode); - createOperationParameterEdge(selfNode, conditionParameter, -1, operationNode); - createOperationParameterEdge(thenNode, thenParameter, -1, operationNode); - createOperationParameterEdge(elseNode, elseParameter, -1, operationNode); - return operationNode; + protected abstract @NonNull ExpressionSynthesizer createExpressionSynthesizer(@NonNull InitUtility initUtility); + + protected @NonNull IfNode createIfNode(@NonNull IfExp ifExp, @NonNull String name, @NonNull Node@NonNull [] sourceAndArgumentNodes) { + InitUtility utility = getRequiredInitUtility(ifExp); + return context.createIfNode(utility, name, ifExp, sourceAndArgumentNodes); } protected @NonNull Edge createIteratedEdge(@NonNull Node sourceNode, @NonNull Node targetNode) { - return context.createIteratedEdge(sourceNode, targetNode); + InitUtility utility = getRequiredInitUtility(targetNode); + return context.createIteratedEdge(utility, sourceNode, targetNode); } protected @NonNull Node createIteratorNode(@NonNull Variable iterator, @NonNull Node sourceNode) { - return context.createIteratorNode(iterator, sourceNode); + InitUtility utility = getRequiredInitUtility(iterator); + return context.createIteratorNode(utility, iterator, sourceNode); } protected @NonNull Node createLetNode(@NonNull Variable letVariable, @NonNull Node inNode) { - return context.createLetVariableNode(letVariable, inNode); + InitUtility utility = getRequiredInitUtility(letVariable); + return context.createLetVariableNode(utility, letVariable, inNode); } protected @NonNull Node createMapLiteral(@NonNull MapLiteralExp mapLiteralExp, @NonNull MapLiteralPart [] mapParts, @NonNull Node @NonNull [] partNodes) { + InitUtility utility = getRequiredInitUtility(mapLiteralExp); assert mapParts.length == partNodes.length; Operation mapOperation = qvtbaseLibraryHelper.getMapOperation(); Node reusedNode = findOperationNode(mapOperation, partNodes); @@ -254,17 +260,15 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi if (nodeName == null) { nodeName = QVTbaseUtil.getName(mapOperation); } - MapLiteralNode mapLiteralNode = context.createMapLiteralNode(isUnconditional(), nodeName, mapLiteralExp, partNodes); + MapLiteralNode mapLiteralNode = context.createMapLiteralNode(utility, nodeName, mapLiteralExp, partNodes); for (int i = 0; i < mapParts.length; i++) { - context.createMapPartEdge(partNodes[i], mapParts[i], mapLiteralNode); + MapLiteralPart mapPart = mapParts[i]; + InitUtility partInitUtility = utility; //getRequiredInitUtility(mapPart); + context.createMapPartEdge(partInitUtility, partNodes[i], mapPart, mapLiteralNode); } return mapLiteralNode; } - protected @NonNull Node createNavigableDataTypeNode(@NonNull Node targetNode, @NonNull NavigationAssignment navigationAssignment) { - return context.createDataTypeNode(targetNode, navigationAssignment); - } - protected @NonNull Node createMapPart(@NonNull MapLiteralPart mapLiteralPart, @NonNull Node keyNode, @NonNull Node valueNode) { TypedElement typedElement = QVTbaseUtil.getOwnedValue(mapLiteralPart); // FIXME use real object Operation partOperation = qvtbaseLibraryHelper.getMapPartOperation(); @@ -278,7 +282,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi if (nodeName == null) { nodeName = QVTbaseUtil.getName(partOperation); } - Node operationNode = context.createMapPartNode(isUnconditional(), nodeName, mapLiteralPart, subPartNodes); + Node operationNode = context.createMapPartNode(resultUtility, nodeName, mapLiteralPart, subPartNodes); Parameter keyParameter = qvtbaseLibraryHelper.getMapPartKeyParameter(); Parameter valueParameter = qvtbaseLibraryHelper.getMapPartValueParameter(); createOperationParameterEdge(keyNode, keyParameter, -1, operationNode); @@ -286,17 +290,23 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi return operationNode; } + // protected @NonNull Node createNavigableDataTypeNode(@NonNull InitUtility utility, @NonNull Node targetNode, @NonNull NavigationAssignment navigationAssignment) { + // return context.createDataTypeNode(utility, targetNode, navigationAssignment); + // } + protected @NonNull Node createNavigableDataTypeNode(@NonNull Node sourceNode, @NonNull Property source2targetProperty) { - assert sourceNode.isMatched(); - return context.createDataTypeNode(sourceNode, source2targetProperty); + InitUtility utility = getRequiredInitUtility(source2targetProperty); + return context.createDataTypeNode(utility, sourceNode, source2targetProperty); } protected @NonNull NavigableEdge createNavigableNavigationEdge(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode) { - return context.createNavigationEdge(sourceNode, source2targetProperty, targetNode, false); + InitUtility utility = getRequiredInitUtility(targetNode); + return context.createNavigationEdge(utility, sourceNode, source2targetProperty, targetNode, false); } - protected @NonNull NavigableEdge createNavigationEdge(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { - return context.createNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); + public @NonNull NavigableEdge createNavigationEdge(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { + InitUtility utility = getRequiredInitUtility(targetNode); + return context.createNavigationEdge(utility, sourceNode, source2targetProperty, targetNode, isPartial); } protected @NonNull NavigableEdge createNavigationOrRealizedEdge(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, @Nullable NavigationAssignment navigationAssignment) { @@ -313,57 +323,61 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi } protected @NonNull Node createNullLiteralNode() { - return context.createNullLiteralNode(isUnconditional(), null); + return context.createNullLiteralNode(resultUtility, null); } protected @NonNull Node createNullLiteralNode(@NonNull NullLiteralExp nullLiteralExp) { - return context.createNullLiteralNode(isUnconditional(), nullLiteralExp); + InitUtility utility = getRequiredInitUtility(nullLiteralExp); + return context.createNullLiteralNode(utility, nullLiteralExp); } protected @NonNull Node createNumericLiteralNode(@NonNull Number numberValue, @NonNull NumericLiteralExp numericLiteralExp) { - return context.createNumericLiteralNode(isUnconditional(), numberValue, numericLiteralExp); + InitUtility utility = getRequiredInitUtility(numericLiteralExp); + return context.createNumericLiteralNode(utility, numberValue, numericLiteralExp); } protected @NonNull Node createOperationCallNode(@NonNull CallExp callExp, @NonNull Operation operation, @NonNull Node @NonNull [] sourceAndArgumentNodes) { Node reusedNode = findOperationNode(operation, sourceAndArgumentNodes); assert reusedNode == null; String nameHint = CompilerUtil.recoverVariableName(callExp); - Node operationNode = context.createOperationCallNode(isUnconditional(), nameHint, operation, callExp, sourceAndArgumentNodes); - if (isUnconditional) { - operationNode.setRequired(); - } + InitUtility utility = getRequiredInitUtility(callExp); + Node operationNode = context.createOperationCallNode(utility, nameHint, operation, callExp, sourceAndArgumentNodes); return operationNode; } protected @NonNull Node createOperationCallNode2(@NonNull String nameHint, @NonNull Role nodeRole, @NonNull Operation operation, @NonNull ClassDatum classDatum, @NonNull Node @NonNull ... sourceAndArgumentNodes) { - Node operationNode = context.createOperationCallNode2(nodeRole, isUnconditional(), nameHint, operation, classDatum, sourceAndArgumentNodes); + Node operationNode = context.createOperationCallNode2(nodeRole, resultUtility, nameHint, operation, classDatum, sourceAndArgumentNodes); return operationNode; } protected @NonNull Edge createOperationParameterEdge(@NonNull Node sourceNode, @NonNull Parameter parameter, int parameterIndex, @NonNull Node targetNode) { - return context.createOperationParameterEdge(sourceNode, parameter, parameterIndex, targetNode); + InitUtility utility = getRequiredInitUtility(sourceNode); + return context.createOperationParameterEdge(utility, sourceNode, parameter, parameterIndex, targetNode); } protected @NonNull Edge createOperationSelfEdge(@NonNull Node sourceNode, @NonNull Type type, @NonNull Node targetNode) { - return context.createOperationSelfEdge(sourceNode, type, targetNode); + InitUtility utility = getRequiredInitUtility(sourceNode); + return context.createOperationSelfEdge(utility, sourceNode, type, targetNode); } - protected @NonNull Edge createPredicateEdge(@NonNull Node sourceNode, @Nullable String name, @NonNull Node targetNode) { - return context.createPredicateEdge(sourceNode, name, targetNode); + protected @NonNull Edge createPredicateEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @Nullable String name, @NonNull Node targetNode) { + return context.createPredicateEdge(utility, sourceNode, name, targetNode); } - protected @NonNull Node createPredicatedClassNode(@NonNull Node parentNode, @NonNull NavigationAssignment navigationAssignment) { - return context.createDependencyClassNode(parentNode, navigationAssignment); - } + // protected @NonNull Node createPredicatedClassNode(@NonNull InitUtility utility, @NonNull Node parentNode, @NonNull NavigationAssignment navigationAssignment) { + // return context.createDependencyClassNode(utility, parentNode, navigationAssignment); + // } - protected @NonNull Node createRealizedDataTypeNode(@NonNull Node sourceNode, @NonNull Property source2targetProperty) { - return context.createRealizedDataTypeNode(sourceNode, source2targetProperty); - } + // protected @NonNull Node createRealizedDataTypeNode(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Property source2targetProperty) { + // return context.createRealizedDataTypeNode(utility, sourceNode, source2targetProperty); + // } - protected @NonNull NavigableEdge createRealizedNavigationEdge(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { - return context.createRealizedNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); + public @NonNull NavigableEdge createRealizedNavigationEdge(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { + InitUtility utility = getRequiredInitUtility(targetNode); + return context.createRealizedNavigationEdge(utility, sourceNode, source2targetProperty, targetNode, isPartial); } protected @NonNull Node createShadow(@NonNull ShadowExp shadowExp, @NonNull ShadowPart [] shadowParts, @NonNull Node @NonNull [] partNodes) { + InitUtility utility = getRequiredInitUtility(shadowExp); assert shadowParts.length == partNodes.length; Operation shadowOperation = qvtbaseLibraryHelper.getShadowOperation(); Node reusedNode = findOperationNode(shadowOperation, partNodes); @@ -375,23 +389,27 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi if (nodeName == null) { nodeName = QVTbaseUtil.getName(shadowOperation); } - ShadowNode shadowLiteralNode = context.createShadowNode(isUnconditional(), nodeName, shadowExp, partNodes); + ShadowNode shadowLiteralNode = context.createShadowNode(utility, nodeName, shadowExp, partNodes); for (int i = 0; i < shadowParts.length; i++) { - context.createShadowPartEdge(partNodes[i], shadowParts[i], shadowLiteralNode); + ShadowPart shadowPart = shadowParts[i]; + InitUtility partInitUtility = getRequiredInitUtility(shadowPart); + context.createShadowPartEdge(partInitUtility, partNodes[i], shadowPart, shadowLiteralNode); } return shadowLiteralNode; } protected @NonNull Node createStepNode(@NonNull String name, @NonNull CallExp callExp, @NonNull Node sourceNode) { - boolean isMatched = isUnconditional && sourceNode.isMatched() && QVTscheduleUtil.isMatched(callExp); - return context.createStepNode(name, callExp, sourceNode, isMatched); + InitUtility utility = getRequiredInitUtility(callExp); + return context.createStepNode(utility, name, callExp, sourceNode); } protected @NonNull Node createStringLiteralNode(@NonNull String stringValue, @NonNull StringLiteralExp stringLiteralExp) { - return context.createStringLiteralNode(isUnconditional(), stringValue, stringLiteralExp); + InitUtility utility = getRequiredInitUtility(stringLiteralExp); + return context.createStringLiteralNode(utility, stringValue, stringLiteralExp); } protected @NonNull Node createTupleLiteral(@NonNull TupleLiteralExp tupleLiteralExp, @NonNull TupleLiteralPart [] tupleParts, @NonNull Node @NonNull [] partNodes) { + InitUtility initUtility = getRequiredInitUtility(tupleLiteralExp); assert tupleParts.length == partNodes.length; Operation tupleOperation = qvtbaseLibraryHelper.getTupleOperation(); Node reusedNode = findOperationNode(tupleOperation, partNodes); @@ -403,47 +421,50 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi if (nodeName == null) { nodeName = QVTbaseUtil.getName(tupleOperation); } - TupleLiteralNode tupleLiteralNode = context.createTupleLiteralNode(isUnconditional(), nodeName, tupleLiteralExp, partNodes); + TupleLiteralNode tupleLiteralNode = context.createTupleLiteralNode(initUtility, nodeName, tupleLiteralExp, partNodes); for (int i = 0; i < tupleParts.length; i++) { - context.createTuplePartEdge(partNodes[i], tupleParts[i], tupleLiteralNode); + TupleLiteralPart tuplePart = tupleParts[i]; + InitUtility partInitUtility = getRequiredInitUtility(tuplePart); + context.createTuplePartEdge(partInitUtility, partNodes[i], tuplePart, tupleLiteralNode); } return tupleLiteralNode; } protected @NonNull TypeLiteralNode createTypeLiteralNode(@NonNull Type typeValue, @NonNull TypeExp typeExp) { - return context.createTypeLiteralNode(isUnconditional(), typeValue, typeExp); + return context.createTypeLiteralNode(getRequiredInitUtility(typeExp), typeValue, typeExp); } protected @NonNull Node doLoopExp(@NonNull LoopExp loopExp, @NonNull Node sourceNode) { + ExpressionSynthesizer conditionalExpressionSynthesizer = getExpressionSynthesizer(resultUtility.getConditionalUtility()); List<@NonNull Variable> ownedIterators = ClassUtil.nullFree(loopExp.getOwnedIterators()); @NonNull Node[] argNodes = new @NonNull Node[1+ownedIterators.size()+(loopExp instanceof IterateExp ? 1 : 0)]; int i = 1; for (@NonNull Variable iterator : ownedIterators) { - Node iteratorNode = createIteratorNode(iterator, sourceNode); + Node iteratorNode = conditionalExpressionSynthesizer.createIteratorNode(iterator, sourceNode); @SuppressWarnings("unused") Type iteratorType = QVTbaseUtil.getType(iterator); // Property iterateProperty = context.getScheduleModel().getIterateProperty(iteratorType); - createIteratedEdge(sourceNode, iteratorNode); + conditionalExpressionSynthesizer.createIteratedEdge(sourceNode, iteratorNode); argNodes[i++] = iteratorNode; } if (loopExp instanceof IterateExp) { Variable accumulator = QVTbaseUtil.getOwnedResult((IterateExp)loopExp); - Node iteratorNode = createIteratorNode(accumulator, sourceNode); + Node iteratorNode = conditionalExpressionSynthesizer.createIteratorNode(accumulator, sourceNode); @SuppressWarnings("unused") Type iteratorType = QVTbaseUtil.getType(accumulator); - createIteratedEdge(sourceNode, iteratorNode); + conditionalExpressionSynthesizer.createIteratedEdge(sourceNode, iteratorNode); argNodes[i++] = iteratorNode; } - Node bodyNode = getExpressionSynthesizer(false).synthesize(loopExp.getOwnedBody()); + Node bodyNode = conditionalExpressionSynthesizer.synthesize(loopExp.getOwnedBody()); argNodes[0] = bodyNode; Iteration referredIteration = QVTbaseUtil.getReferredIteration(loopExp); Node accumulateNode = findOperationNode(referredIteration, argNodes); if (accumulateNode == null) { accumulateNode = createOperationCallNode(loopExp, referredIteration, argNodes); createOperationParameterEdge(sourceNode, qvtbaseLibraryHelper.getLoopSourceParameter(), -1, accumulateNode); - createOperationParameterEdge(bodyNode, qvtbaseLibraryHelper.getLoopBodyParameter(), -1, accumulateNode); + conditionalExpressionSynthesizer.createOperationParameterEdge(bodyNode, qvtbaseLibraryHelper.getLoopBodyParameter(), -1, accumulateNode); for (int j = 1 ; j <= ownedIterators.size(); j++) { - createOperationParameterEdge(argNodes[j], qvtbaseLibraryHelper.getLoopIteratorsParameter(), j-1, accumulateNode); + conditionalExpressionSynthesizer.createOperationParameterEdge(argNodes[j], qvtbaseLibraryHelper.getLoopIteratorsParameter(), j-1, accumulateNode); } } return accumulateNode; @@ -483,7 +504,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi } protected @Nullable Node doOperationCallExp(@NonNull OperationCallExp operationCallExp, @Nullable Node sourceNode) { - boolean isMatched = isUnconditional() || QVTscheduleUtil.isMatched(operationCallExp); + boolean isRequired = operationCallExp.isIsRequired(); Operation referredOperation = QVTbaseUtil.getReferredOperation(operationCallExp); String operationName = ClassUtil.nonNullState(referredOperation.getName()); OCLExpression ownedSource = operationCallExp.getOwnedSource(); @@ -494,13 +515,10 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi for (int i = 0; i < iSize; i++) { argNodes[i] = synthesize(ownedArguments.get(i)); } - ExpressionSynthesizer nestedAnalyzer = getExpressionSynthesizer(isMatched); + ExpressionSynthesizer nestedAnalyzer = getRequiredExpressionSynthesizer(isRequired); Node operationNode = findOperationNode(referredOperation, argNodes); if (operationNode == null) { operationNode = nestedAnalyzer.createOperationCallNode(operationCallExp, referredOperation, argNodes); - if (isUnconditional()) { - operationNode.setRequired(); - } for (int i = 0; i < iSize; i++) { Parameter parameter = QVTbaseUtil.getOwnedParameter(referredOperation, i); nestedAnalyzer.createOperationParameterEdge(argNodes[i], parameter, -1, operationNode); @@ -618,7 +636,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi Operation ifOperation = qvtbaseLibraryHelper.getIfOperation(); @NonNull Node [] sourceAndArgumentNodes = new @NonNull Node[] { isNonNullNode, navigationNode, nullNode2 }; String nodeName = QVTbaseUtil.getName(ifOperation); - Node ifNode = context.createIfNode2(isUnconditional(), nodeName, QVTscheduleUtil.getClassDatum(navigationNode), sourceAndArgumentNodes); + Node ifNode = context.createIfNode2(resultUtility, nodeName, QVTscheduleUtil.getClassDatum(navigationNode), sourceAndArgumentNodes); Parameter conditionParameter = qvtbaseLibraryHelper.getIfConditionParameter(); Parameter thenParameter = qvtbaseLibraryHelper.getIfThenParameter(); Parameter elseParameter = qvtbaseLibraryHelper.getIfElseParameter(); @@ -660,6 +678,9 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi } } if (i == iSize) { + if (!resultUtility.isConditional()) { + assert !reusedNode.isConditional(); + } return reusedNode; } } @@ -671,19 +692,44 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi return null; } - public @NonNull ExpressionSynthesizer getExpressionSynthesizer(boolean isUnconditional) { - if (isUnconditional) { - return unconditionalExpressionSynthesizer; - } - else if (!this.isUnconditional) { - return this; + // protected final @NonNull InitUtility getConditionalUtility() { + // boolean isNullable = resultUtility.isNullable(); + // return isNullable ? InitUtility.NULLABLE_CONDITIONAL : InitUtility.NON_NULL_CONDITIONAL; + // } + + public @NonNull ExpressionSynthesizer getExpressionSynthesizer(@NonNull InitUtility initUtility) { + if (nonNullMatchedExpressionSynthesizer != this) { + return nonNullMatchedExpressionSynthesizer.getExpressionSynthesizer(initUtility); } - else { - ExpressionSynthesizer conditionalExpressionSynthesizer2 = conditionalExpressionSynthesizer; - if (conditionalExpressionSynthesizer2 == null) { - conditionalExpressionSynthesizer = conditionalExpressionSynthesizer2 = createConditionalExpressionSynthesizer(); + assert this == nonNullMatchedExpressionSynthesizer; + switch (initUtility) { + case NON_NULL_MATCHED: { + return this; + } + case NULLABLE_MATCHED: { + ExpressionSynthesizer nullableMatchedExpressionSynthesizer2 = nullableMatchedExpressionSynthesizer; + if (nullableMatchedExpressionSynthesizer2 == null) { + nullableMatchedExpressionSynthesizer = nullableMatchedExpressionSynthesizer2 = createExpressionSynthesizer(initUtility); + } + return nullableMatchedExpressionSynthesizer2; + } + case NON_NULL_CONDITIONAL: { + ExpressionSynthesizer nonNullConditionalExpressionSynthesizer2 = nonNullConditionalExpressionSynthesizer; + if (nonNullConditionalExpressionSynthesizer2 == null) { + nonNullConditionalExpressionSynthesizer = nonNullConditionalExpressionSynthesizer2 = createExpressionSynthesizer(initUtility); + } + return nonNullConditionalExpressionSynthesizer2; + } + case NULLABLE_CONDITIONAL: { + ExpressionSynthesizer nullableConditionalExpressionSynthesizer2 = nullableConditionalExpressionSynthesizer; + if (nullableConditionalExpressionSynthesizer2 == null) { + nullableConditionalExpressionSynthesizer = nullableConditionalExpressionSynthesizer2 = createExpressionSynthesizer(initUtility); + } + return nullableConditionalExpressionSynthesizer2; + } + default: { + throw new UnsupportedOperationException(); } - return conditionalExpressionSynthesizer2; } } @@ -695,6 +741,10 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi return operationDependencyAnalysis2; } */ + protected final @NonNull InitUtility getInitUtility() { + return resultUtility; + } + /** * Return the navigation edge suitable for navigating from sourceNode to targetNode via source2targetProperty, * re-using an already created edge if available, otherwise creating the edge. @@ -733,7 +783,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi if (navigationAssignment == null) { Node stepNode = createNavigableDataTypeNode(sourceNode, source2targetProperty); navigationEdge = createNavigationOrRealizedEdge(sourceNode, source2targetProperty, stepNode, navigationAssignment); - context.createEqualsEdge(targetNode, stepNode); + context.createEqualsEdge(resultUtility, targetNode, stepNode); } else { // Node stepNode = createNavigableDataTypeNode(targetNode, navigationAssignment); @@ -746,7 +796,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi else { // if (!navigationEdge.isRealized() || targetNode.isRealized()) { if (targetNode != navigationEdge.getEdgeTarget()) { - context.createEqualsEdge(targetNode, navigationEdge.getEdgeTarget()); + context.createEqualsEdge(getRequiredInitUtility(navigationEdge.getEdgeTarget()), targetNode, navigationEdge.getEdgeTarget()); } } return navigationEdge; @@ -758,7 +808,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi if (navigationEdge != null) { Node target = navigationEdge.getEdgeTarget(); if (target != targetNode) { - context.createEqualsEdge(targetNode, target); + context.createEqualsEdge(getRequiredInitUtility(targetNode), targetNode, target); } } else { @@ -800,7 +850,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi Node valueNode = navigationEdge.getEdgeTarget(); assert valueNode.isRealized(); Type type = source2targetProperty.getType(); - Edge equalsEdge = context.createEqualsEdge(targetNode, valueNode); + Edge equalsEdge = context.createEqualsEdge(resultUtility, targetNode, valueNode); if (type instanceof DataType) { assert equalsEdge.isRealized(); // ?? obsolete legacy check that never seems to be used } @@ -818,6 +868,44 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi return createNavigationOrRealizedEdge(sourceNode, source2targetProperty, targetNode, navigationAssignment); } + protected final @NonNull InitUtility getNonNullUtility() { + boolean isConditional = resultUtility.isConditional(); + return isConditional ? InitUtility.NON_NULL_CONDITIONAL : InitUtility.NON_NULL_MATCHED; + } + + protected final @NonNull InitUtility getNullableUtility() { + boolean isConditional = resultUtility.isConditional(); + return isConditional ? InitUtility.NULLABLE_CONDITIONAL : InitUtility.NULLABLE_MATCHED; + } + + public @NonNull ExpressionSynthesizer getRequiredExpressionSynthesizer(boolean isRequired) { + return getExpressionSynthesizer(getRequiredInitUtility(isRequired)); + } + + public @NonNull InitUtility getRequiredInitUtility(boolean isRequired) { + return isRequired ? getNonNullUtility() : getNullableUtility(); + } + + public @NonNull InitUtility getRequiredInitUtility(@NonNull TypedElement typedElement) { + return getRequiredInitUtility(typedElement.isIsRequired()); + } + + protected @NonNull InitUtility getRequiredInitUtility(@NonNull InitUtility initUtility) { + boolean isConditional = this.resultUtility.isConditional(); + boolean isNullable = initUtility.isNullable(); + if (isConditional) { + return isNullable ? InitUtility.NULLABLE_CONDITIONAL : InitUtility.NON_NULL_CONDITIONAL; + } + else { + isNullable = isNullable && this.resultUtility.isNullable(); + return isNullable ? InitUtility.NULLABLE_MATCHED : InitUtility.NON_NULL_MATCHED; + } + } + + protected @NonNull InitUtility getRequiredInitUtility(@NonNull Node node) { + return getRequiredInitUtility(node.getInitUtility()); + } + private void instantiate(@NonNull Node instantiatedNode, @NonNull Node referenceNode) { for (@NonNull Edge referenceEdge : QVTscheduleUtil.getOutgoingEdges(referenceNode)) { if (referenceEdge instanceof NavigationEdge) { @@ -827,7 +915,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi String name = QVTscheduleUtil.getName(referenceTargetNode); ClassDatum classDatum = QVTscheduleUtil.getClassDatum(referenceTargetNode); Node instantiatedTargetNode = createDependencyNode(name, classDatum); - createNavigationEdge(instantiatedNode, QVTscheduleUtil.getReferredProperty(navigationEdge), instantiatedTargetNode, false); + createNavigationEdge(/*InitUtility.DEPENDENCY,*/ instantiatedNode, QVTscheduleUtil.getReferredProperty(navigationEdge), instantiatedTargetNode, false); instantiate(instantiatedTargetNode, referenceTargetNode); } } @@ -837,14 +925,10 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi } } - protected final boolean isUnconditional() { - return isUnconditional; - } - /** * Rewrite a CastEdge and its target node as an oclAsType call. THe castEdge and its target node are destroyed by the replacement. * - * REturns the operation node, + * Returns the operation node, */ public @NonNull Node rewriteCastEdgeAsOclAsType(@NonNull CastEdge castEdge) { Node sourceNode = QVTscheduleUtil.getSourceNode(castEdge); @@ -858,14 +942,11 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi // Create oclAsType operation node, type node and argument edges. // Node typeNode = createTypeLiteralNode(PivotUtil.getReferredType(typeArgument), typeArgument); - ExpressionSynthesizer nestedAnalyzer = getExpressionSynthesizer(false); + ExpressionSynthesizer nestedAnalyzer = this; //getExpressionSynthesizer(Utility.CONDITIONAL); @NonNull Node[] sourceAndArgumentNodes = new @NonNull Node[] {sourceNode, typeNode}; Node operationNode = findOperationNode(referredOperation, sourceAndArgumentNodes); if (operationNode == null) { operationNode = nestedAnalyzer.createOperationCallNode(operationCallExp, referredOperation, sourceAndArgumentNodes); - if (isUnconditional()) { - operationNode.setRequired(); - } nestedAnalyzer.createOperationSelfEdge(sourceNode, sourceType, operationNode); Parameter parameter = QVTbaseUtil.getOwnedParameter(referredOperation, 0); nestedAnalyzer.createOperationParameterEdge(typeNode, parameter, -1, operationNode); @@ -973,7 +1054,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi private @Nullable Node synthesizeOperationCallExp_includes(@NonNull Node sourceNode, @NonNull OperationCallExp operationCallExp) { Node targetNode = synthesize(operationCallExp.getOwnedArguments().get(0)); String name = operationCallExp.getReferredOperation().getName(); - createPredicateEdge(sourceNode, "«" + name + "»", targetNode); + createPredicateEdge(resultUtility, sourceNode, "«" + name + "»", targetNode); if (sourceNode.isDataType()) { // expecting a CollectionType for (@NonNull Edge edge : QVTscheduleUtil.getIncomingEdges(sourceNode)) { if (edge instanceof NavigationEdge) { @@ -1032,12 +1113,6 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi String name = "a" + castType.getName(); // assert name != null; Node castNode = createStepNode(name, operationCallExp, sourceNode); - if (castIsRequired) { - castNode.setRequired(); - if ((castNode instanceof MappingNode) && sourceNode.isMatched()) { - ((MappingNode)castNode).setMatched(true); - } - } createCastEdge(sourceNode, castClassDatum, castNode); OCLExpression argument = operationCallExp.getOwnedArguments().get(0); if (!(argument instanceof TypeExp)) { @@ -1139,7 +1214,7 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi } String name = oclContainerProperty.getName(); assert (name != null) && (type != null); - FutureVariable variable = new FutureVariable("-container-", type, oclContainerProperty.isIsRequired(), sourceNode.getClassDatumAnalysis().getDomainUsage()); + FutureVariable variable = new FutureVariable("-container-", type, oclContainerProperty.isIsRequired(), sourcegetClassDatumAnalysis().getDomainUsage()); ClassNode targetReferenceNode = context.getReferenceNode(variable); context.addPredicateEdge((ClassNode) sourceNode, oclContainerProperty, targetReferenceNode); return targetReferenceNode; */ @@ -1156,6 +1231,13 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi } @Override + public String toString() { + String name = getClass().getName(); + int index = name.lastIndexOf('.'); + return resultUtility + " " + (index < 0 ? name : name.substring(index+1)); + } + + @Override public @NonNull Node visiting(@NonNull Visitable visitable) { throw new UnsupportedOperationException(getClass().getSimpleName() + ": " + visitable.getClass().getSimpleName()); } @@ -1178,8 +1260,8 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi partNodes[i] = synthesize(collectionPart); collectionParts[i] = collectionPart; } - boolean isMatched = QVTscheduleUtil.isMatched(collectionLiteralExp); - ExpressionSynthesizer nestedAnalyzer = getExpressionSynthesizer(isMatched); + boolean isRequired = collectionLiteralExp.isIsRequired(); + ExpressionSynthesizer nestedAnalyzer = getRequiredExpressionSynthesizer(isRequired); return nestedAnalyzer.createCollectionLiteral(collectionLiteralExp, collectionParts, partNodes); } @@ -1192,9 +1274,9 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi public @NonNull Node visitCollectionRange(@NonNull CollectionRange collectionRange) { Node firstNode = synthesize(collectionRange.getOwnedFirst()); Node lastNode = synthesize(collectionRange.getOwnedLast()); - boolean isMatched = QVTscheduleUtil.isMatched(collectionRange); - ExpressionSynthesizer nestedAnalyzer = getExpressionSynthesizer(isMatched); - return nestedAnalyzer.createCollectionRange(collectionRange, firstNode, lastNode); + boolean isRequired = collectionRange.isIsRequired(); + ExpressionSynthesizer nestedAnalyzer = getRequiredExpressionSynthesizer(isRequired); + return nestedAnalyzer.createCollectionRange(resultUtility, collectionRange, firstNode, lastNode); } @Override @@ -1220,13 +1302,32 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi @Override public @NonNull Node visitIfExp(@NonNull IfExp ifExp) { - ExpressionSynthesizer conditionalExpressionSynthesizer = getExpressionSynthesizer(false); + ExpressionSynthesizer conditionalExpressionSynthesizer = getExpressionSynthesizer(resultUtility.getConditionalUtility()); Node selfNode = synthesize(ifExp.getOwnedCondition()); Node thenNode = conditionalExpressionSynthesizer.synthesize(ifExp.getOwnedThen()); Node elseNode = conditionalExpressionSynthesizer.synthesize(ifExp.getOwnedElse()); - boolean isMatched = QVTscheduleUtil.isMatched(ifExp); - ExpressionSynthesizer nestedAnalyzer = getExpressionSynthesizer(isMatched); - return nestedAnalyzer.createIf(ifExp, selfNode, thenNode, elseNode); + Operation ifOperation = qvtbaseLibraryHelper.getIfOperation(); + @NonNull Node [] sourceAndArgumentNodes = new @NonNull Node[] { selfNode, thenNode, elseNode }; + Node reusedNode = findOperationNode(ifOperation, sourceAndArgumentNodes); + if (reusedNode != null) { + // reusedNode.addTypedElement(ifExp); + return reusedNode; + } + String nodeName = CompilerUtil.recoverVariableName(ifExp); + if (nodeName == null) { + nodeName = QVTbaseUtil.getName(ifOperation); + } + // Node operationNode = nestedAnalyzer.createOperationNode(nodeName, typedElement, sourceAndArgumentNodes); + Node operationNode = createIfNode(ifExp, nodeName, sourceAndArgumentNodes); + // org.eclipse.ocl.pivot.Class selfType = standardLibraryHelper.getStandardLibrary().getBooleanType(); + Parameter conditionParameter = qvtbaseLibraryHelper.getIfConditionParameter(); + Parameter thenParameter = qvtbaseLibraryHelper.getIfThenParameter(); + Parameter elseParameter = qvtbaseLibraryHelper.getIfElseParameter(); + // createOperationSelfEdge(selfNode, selfType, operationNode); + createOperationParameterEdge(selfNode, conditionParameter, -1, operationNode); + conditionalExpressionSynthesizer.createOperationParameterEdge(thenNode, thenParameter, -1, operationNode); + conditionalExpressionSynthesizer.createOperationParameterEdge(elseNode, elseParameter, -1, operationNode); + return operationNode; } @Override @@ -1276,8 +1377,8 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi partNodes[i] = synthesize(mapPart); mapParts[i] = mapPart; } - boolean isMatched = QVTscheduleUtil.isMatched(mapLiteralExp); - ExpressionSynthesizer nestedAnalyzer = getExpressionSynthesizer(isMatched); + boolean isRequired = mapLiteralExp.isIsRequired(); + ExpressionSynthesizer nestedAnalyzer = getRequiredExpressionSynthesizer(isRequired); return nestedAnalyzer.createMapLiteral(mapLiteralExp, mapParts, partNodes); } @@ -1285,8 +1386,10 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi public @NonNull Node visitMapLiteralPart(@NonNull MapLiteralPart mapLiteralPart) { Node keyNode = synthesize(QVTbaseUtil.getOwnedKey(mapLiteralPart)); Node valueNode = synthesize(QVTbaseUtil.getOwnedValue(mapLiteralPart)); - boolean isMatched = QVTscheduleUtil.isMatched(mapLiteralPart); - ExpressionSynthesizer nestedAnalyzer = getExpressionSynthesizer(isMatched); + OCLExpression key = QVTbaseUtil.getOwnedKey(mapLiteralPart); + OCLExpression value = QVTbaseUtil.getOwnedValue(mapLiteralPart); + boolean isRequired = key.isIsRequired() && value.isIsRequired(); + ExpressionSynthesizer nestedAnalyzer = getRequiredExpressionSynthesizer(isRequired); return nestedAnalyzer.createMapPart(mapLiteralPart, keyNode, valueNode); } @@ -1314,9 +1417,9 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi @Override public @Nullable Node visitOperationCallExp(@NonNull OperationCallExp operationCallExp) { - boolean isMatched = isUnconditional() || QVTscheduleUtil.isMatched(operationCallExp); - if (isUnconditional() && !isMatched) { - return getExpressionSynthesizer(false).visitOperationCallExp(operationCallExp); + boolean isRequired = !resultUtility.isConditional() || operationCallExp.isIsRequired(); + if (!resultUtility.isConditional() && !isRequired) { + return getExpressionSynthesizer(resultUtility.getConditionalUtility()).visitOperationCallExp(operationCallExp); } OCLExpression ownedSource = operationCallExp.getOwnedSource(); if (ownedSource instanceof VariableExp) { @@ -1353,8 +1456,8 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi partNodes[i] = synthesize(shadowPart); shadowParts[i] = shadowPart; } - boolean isMatched = QVTscheduleUtil.isMatched(shadowExp); - ExpressionSynthesizer nestedAnalyzer = getExpressionSynthesizer(isMatched); + boolean isRequired = shadowExp.isIsRequired(); + ExpressionSynthesizer nestedAnalyzer = getRequiredExpressionSynthesizer(isRequired); return nestedAnalyzer.createShadow(shadowExp, shadowParts, partNodes); } @@ -1381,8 +1484,8 @@ public abstract class ExpressionSynthesizer extends AbstractExtendingQVTbaseVisi partNodes[i] = synthesize(tuplePart); tupleParts[i] = tuplePart; } - boolean isMatched = QVTscheduleUtil.isMatched(tupleLiteralExp); - ExpressionSynthesizer nestedAnalyzer = getExpressionSynthesizer(isMatched); + boolean isRequired = tupleLiteralExp.isIsRequired(); + ExpressionSynthesizer nestedAnalyzer = getRequiredExpressionSynthesizer(isRequired); return nestedAnalyzer.createTupleLiteral(tupleLiteralExp, tupleParts, partNodes); } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/HeadNodeGroup.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/HeadNodeGroup.java index 06263ecb7..5774a163a 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/HeadNodeGroup.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/HeadNodeGroup.java @@ -57,11 +57,11 @@ public abstract class HeadNodeGroup implements Nameable private boolean accumulateReachableTargets(@NonNull Deque<@NonNull Node> workList) { Node sourceNode = workList.removeFirst(); - assert sourceNode.isMatched(); + assert sourceNode.isUnconditional(); boolean gotOne = false; for (@NonNull Edge source2targetEdge : QVTscheduleUtil.getOutgoingEdges(sourceNode)) { Node targetNode = QVTscheduleUtil.getTargetNode(source2targetEdge); - if (targetNode.isMatched() && canBeSameGroup(sourceNode, source2targetEdge) && !uniqueNodes.contains(targetNode)) { + if (targetNode.isUnconditional() && canBeSameGroup(sourceNode, source2targetEdge) && !uniqueNodes.contains(targetNode)) { if (source2targetEdge.isCast()) { // Can happen when analyzing traced heads uniqueNodes.add(targetNode); workList.add(targetNode); @@ -83,7 +83,7 @@ public abstract class HeadNodeGroup implements Nameable for (@NonNull Edge argumentEdge : QVTscheduleUtil.getIncomingEdges(targetNode)) { if ((argumentEdge != source2targetEdge) && argumentEdge.isComputation()) { Node argumentNode = QVTscheduleUtil.getSourceNode(argumentEdge); - if (argumentNode.isMatched()) { + if (argumentNode.isUnconditional()) { if (!argumentNode.isConstant() && !uniqueNodes.contains(argumentNode)) { allArgumentsReachable = false; break; @@ -103,7 +103,7 @@ public abstract class HeadNodeGroup implements Nameable if (target2sourceEdge instanceof KeyPartEdge) { // FIXME KeyPartEdge is bidirectional Node targetNode = QVTscheduleUtil.getSourceNode(target2sourceEdge); uniqueNodes.add(targetNode); - if (targetNode.isMatched()) { + if (targetNode.isUnconditional()) { workList.add(targetNode); } gotOne = true; @@ -112,7 +112,7 @@ public abstract class HeadNodeGroup implements Nameable Node targetNode = QVTscheduleUtil.getSourceNode(target2sourceEdge); if (isNonTopWhen(targetNode)) { uniqueNodes.add(targetNode); - if (targetNode.isMatched()) { + if (targetNode.isUnconditional()) { workList.add(targetNode); } gotOne = true; diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/LoadingRegionAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/LoadingRegionAnalysis.java index 7b9ff7fac..03c71057b 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/LoadingRegionAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/LoadingRegionAnalysis.java @@ -25,6 +25,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.NavigationEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.QVTscheduleFactory; import org.eclipse.qvtd.pivot.qvtschedule.Role; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.ComposedNode; @@ -60,7 +61,7 @@ public class LoadingRegionAnalysis extends RegionHelper<@NonNull LoadingRegion> public @NonNull Node createComposingNode(@NonNull String name, @NonNull ClassDatum classDatum) { Role nodeRole = Role.LOADED; ComposedNode node = QVTscheduleFactory.eINSTANCE.createComposedNode(); - node.initialize(nodeRole, region, name, classDatum); + node.initialize(nodeRole, region, InitUtility.COMPOSED, name, classDatum); return node; } @@ -117,7 +118,7 @@ public class LoadingRegionAnalysis extends RegionHelper<@NonNull LoadingRegion> if (introducedNode == null) { introducedNode = createComposingNode("«" + elementType.getName() + "-null»", childrenClassDatum); property2node.put(null, introducedNode); - createNavigationEdge(getNullNode(), parent2childProperty, introducedNode, false); + createNavigationEdge(InitUtility.COMPOSED, getNullNode(), parent2childProperty, introducedNode, false); } } else if (containingClassDatum != null) { // Non-root oclContainer ownership @@ -131,7 +132,7 @@ public class LoadingRegionAnalysis extends RegionHelper<@NonNull LoadingRegion> introducedNode = createComposingNode("«" + elementType.getName() + "-oclContents»", childrenClassDatum); type2node.put(containingClassDatum, introducedNode); Node containerNode = createComposingNode("«" + containingClassDatum.getName() + "-oclContainer»", containingClassDatum); - createNavigationEdge(containerNode, parent2childProperty, introducedNode, false); + createNavigationEdge(InitUtility.COMPOSED, containerNode, parent2childProperty, introducedNode, false); } } else { // Knonw distinctive containment @@ -148,7 +149,7 @@ public class LoadingRegionAnalysis extends RegionHelper<@NonNull LoadingRegion> assert owningClass != null; containingClassDatum = scheduleManager.getClassDatum(typedModel, owningClass); Node containerNode = createComposingNode("«" + owningClass.getName() + "-" + parent2childProperty.getName() + "»", containingClassDatum); - createNavigationEdge(containerNode, parent2childProperty, introducedNode, false); + createNavigationEdge(InitUtility.COMPOSED, containerNode, parent2childProperty, introducedNode, false); } } return introducedNode; @@ -157,7 +158,7 @@ public class LoadingRegionAnalysis extends RegionHelper<@NonNull LoadingRegion> protected @NonNull Node getNullNode() { Node nullNode2 = nullNode; if (nullNode2 == null) { - nullNode = nullNode2 = createNullLiteralNode(true, null); + nullNode = nullNode2 = createNullLiteralNode(InitUtility.COMPOSED, null); } return nullNode2; } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/OperationRegionHelper.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/OperationRegionHelper.java index 2b671a265..be7942825 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/OperationRegionHelper.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/OperationRegionHelper.java @@ -17,6 +17,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.OperationRegion; import org.eclipse.qvtd.pivot.qvtschedule.PatternTypedNode; import org.eclipse.qvtd.pivot.qvtschedule.QVTscheduleFactory; import org.eclipse.qvtd.pivot.qvtschedule.Role; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; public class OperationRegionHelper extends RegionHelper<@NonNull OperationRegion> { @@ -24,28 +25,25 @@ public class OperationRegionHelper extends RegionHelper<@NonNull OperationRegion super(scheduleManager, region); } - public @NonNull Node createOperationElementNode(@NonNull String name, @NonNull ClassDatum classDatum, @NonNull Node sourceNode) { + public @NonNull Node createOperationElementNode(@NonNull InitUtility initUtility, @NonNull String name, @NonNull ClassDatum classDatum, @NonNull Node sourceNode) { Role nodeRole = getNodeRole(sourceNode); PatternTypedNode node = QVTscheduleFactory.eINSTANCE.createPatternTypedNode(); - node.initialize(nodeRole, region, name, classDatum); - node.setMatched(true); + node.initialize(nodeRole, region, initUtility, name, classDatum); return node; } - public @NonNull Node createOperationParameterNode(@NonNull String name, @NonNull ClassDatum classDatum) { + public @NonNull Node createOperationParameterNode(@NonNull InitUtility initUtility, @NonNull String name, @NonNull ClassDatum classDatum) { Role nodeRole = Role.PREDICATED; PatternTypedNode node = QVTscheduleFactory.eINSTANCE.createPatternTypedNode(); - node.initialize(nodeRole, region, name, classDatum); - node.setMatched(true); + node.initialize(nodeRole, region, initUtility, name, classDatum); node.setHead(); return node; } - public @NonNull Node createOperationResultNode(@NonNull String name, @NonNull ClassDatum classDatum, @NonNull Node sourceNode) { + public @NonNull Node createOperationResultNode(@NonNull InitUtility initUtility, @NonNull String name, @NonNull ClassDatum classDatum, @NonNull Node sourceNode) { Role nodeRole = getNodeRole(sourceNode); PatternTypedNode node = QVTscheduleFactory.eINSTANCE.createPatternTypedNode(); - node.initialize(nodeRole, region, name, classDatum); - node.setMatched(false); + node.initialize(nodeRole, region, initUtility, name, classDatum); return node; } }
\ No newline at end of file diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RegionHelper.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RegionHelper.java index 3dadb7e72..14fcbc075 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RegionHelper.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RegionHelper.java @@ -103,6 +103,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.TypeLiteralNode; import org.eclipse.qvtd.pivot.qvtschedule.UnknownNode; import org.eclipse.qvtd.pivot.qvtschedule.VariableNode; import org.eclipse.qvtd.pivot.qvtschedule.utilities.DomainUsage; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; import org.eclipse.qvtd.runtime.utilities.QVTruntimeUtil; @@ -135,57 +136,56 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return basicPartition; } - public @NonNull BooleanLiteralNode createBooleanLiteralNode(boolean isTrue) { + public @NonNull BooleanLiteralNode createBooleanLiteralNode(@NonNull InitUtility utility, boolean isTrue) { ClassDatum classDatum = scheduleManager.getBooleanClassDatum(); BooleanLiteralNode booleanLiteralNode = QVTscheduleFactory.eINSTANCE.createBooleanLiteralNode(); - booleanLiteralNode.initialize(Role.CONSTANT, region, Boolean.toString(isTrue), classDatum); - booleanLiteralNode.setMatched(true); + booleanLiteralNode.initialize(Role.CONSTANT, region, utility, Boolean.toString(isTrue), classDatum); booleanLiteralNode.setBooleanValue(isTrue); return booleanLiteralNode; } - public @NonNull BooleanLiteralNode createBooleanLiteralNode(boolean isMatched, boolean booleanValue, @NonNull BooleanLiteralExp booleanLiteralExp) { + public @NonNull BooleanLiteralNode createBooleanLiteralNode(@NonNull InitUtility utility, boolean booleanValue, @Nullable BooleanLiteralExp booleanLiteralExp) { Role nodeRole = getOperationNodePhase(region, booleanLiteralExp); + ClassDatum classDatum = scheduleManager.getBooleanClassDatum(); BooleanLiteralNode booleanLiteralNode = QVTscheduleFactory.eINSTANCE.createBooleanLiteralNode(); - booleanLiteralNode.initialize(nodeRole, region, Boolean.toString(booleanValue), scheduleManager.getClassDatum(booleanLiteralExp)); - booleanLiteralNode.setMatched(isMatched); + booleanLiteralNode.initialize(nodeRole, region, utility, Boolean.toString(booleanValue), classDatum); booleanLiteralNode.setBooleanValue(booleanValue); - booleanLiteralNode.setOriginatingElement(booleanLiteralExp); + if (booleanLiteralExp != null) { + booleanLiteralNode.setOriginatingElement(booleanLiteralExp); + } return booleanLiteralNode; } - public @NonNull CastEdge createCastEdge(@NonNull Node sourceNode, @NonNull ClassDatum classDatum, @NonNull Node targetNode) { + public @NonNull CastEdge createCastEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull ClassDatum classDatum, @NonNull Node targetNode) { Role phase = mergeToLessKnownPhase(getNodeRole(sourceNode), getNodeRole(targetNode)); Role edgeRole = phase; CastEdge castEdge = QVTscheduleFactory.eINSTANCE.createCastEdge(); - castEdge.initialize(edgeRole, sourceNode, classDatum, targetNode); + castEdge.initialize(edgeRole, utility, sourceNode, classDatum, targetNode); return castEdge; } - public @NonNull CollectionLiteralNode createCollectionLiteralNode(boolean isMatched, @NonNull String name, @NonNull CollectionLiteralExp collectionLiteralExp, @NonNull Node @NonNull [] partNodes) { + public @NonNull CollectionLiteralNode createCollectionLiteralNode(@NonNull InitUtility utility, @NonNull String name, @NonNull CollectionLiteralExp collectionLiteralExp, @NonNull Node @NonNull [] partNodes) { Role nodeRole = getOperationNodePhase(region, collectionLiteralExp, partNodes); CollectionLiteralNode node = QVTscheduleFactory.eINSTANCE.createCollectionLiteralNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(collectionLiteralExp)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, scheduleManager.getClassDatum(collectionLiteralExp)); node.setOriginatingElement(collectionLiteralExp); return node; } - public @NonNull Edge createCollectionPartEdge(@NonNull Node sourceNode, @NonNull CollectionLiteralPart collectionPart, @NonNull Node targetNode) { + public @NonNull Edge createCollectionPartEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull CollectionLiteralPart collectionPart, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); CollectionPartEdge edge = QVTscheduleFactory.eINSTANCE.createCollectionPartEdge(); edge.setReferredPart(collectionPart); String partName = collectionPart.getName(); // Always null String label = partName != null ? "«" + partName + "»" : "«part»"; - edge.initialize(edgeRole, sourceNode, label, targetNode); + edge.initialize(edgeRole, utility, sourceNode, label, targetNode); return edge; } - public @NonNull CollectionRangeNode createCollectionRangeNode(boolean isMatched, @NonNull String name, @NonNull CollectionRange collectionRange, @NonNull Node @NonNull [] argNodes) { + public @NonNull CollectionRangeNode createCollectionRangeNode(@NonNull InitUtility utility, @NonNull String name, @NonNull CollectionRange collectionRange, @NonNull Node @NonNull [] argNodes) { Role nodeRole = getOperationNodePhase(region, collectionRange, argNodes); CollectionRangeNode node = QVTscheduleFactory.eINSTANCE.createCollectionRangeNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(collectionRange)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, scheduleManager.getClassDatum(collectionRange)); node.setOriginatingElement(collectionRange); return node; } @@ -199,21 +199,19 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return cyclicPartition; } - public @NonNull Node createDataTypeNode(@NonNull String name, @NonNull Node sourceNode, @NonNull NavigationCallExp navigationCallExp) { + public @NonNull Node createDataTypeNode(@NonNull InitUtility utility, @NonNull String name, @NonNull Node sourceNode, @NonNull NavigationCallExp navigationCallExp) { Property property = PivotUtil.getReferredProperty(navigationCallExp); - boolean isMatched = sourceNode.isMatched() && isMatched(property); Role nodeRole = getPatternNodeRole(sourceNode, property); assert sourceNode.isClass() || (property.getOpposite() != null); // FIXME review is this relevant? // String name = property.getName(); // assert name != null; PatternTypedNode node = QVTscheduleFactory.eINSTANCE.createPatternTypedNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(navigationCallExp)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, scheduleManager.getClassDatum(navigationCallExp)); node.setOriginatingElement(navigationCallExp); return node; } - public @NonNull Node createDataTypeNode(@NonNull Node targetNode, @NonNull NavigationAssignment navigationAssignment) { + public @NonNull Node createDataTypeNode(@NonNull InitUtility utility, @NonNull Node targetNode, @NonNull NavigationAssignment navigationAssignment) { Role nodeRole = getNodeRole(targetNode); Property property = QVTcoreUtil.getTargetProperty(navigationAssignment); // PatternNodeRole nodeRole = PatternNodeRole.getDataTypeNodeRole(targetNode, property); @@ -225,18 +223,17 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N TypedModel typedModel = getTypedModel(targetNode); ClassDatum classDatum = scheduleManager.getClassDatum(typedModel, type); PatternTypedNode node = QVTscheduleFactory.eINSTANCE.createPatternTypedNode(); - node.initialize(nodeRole, region, name, classDatum); - node.setMatched(true); + node.initialize(nodeRole, region, utility, name, classDatum); node.setOriginatingElement(property); return node; } - public @NonNull Node createDataTypeNode(@NonNull Node sourceNode, @NonNull Property property) { + public @NonNull Node createDataTypeNode(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Property property) { Role nodeRole = getPatternNodeRole(sourceNode, property); - return createPatternNode(nodeRole, sourceNode, property, sourceNode.isMatched() && isMatched(property)); + return createPatternNode(nodeRole, utility, sourceNode, property); } - public @NonNull Node createDependencyClassNode(@NonNull Node parentNode, @NonNull NavigationAssignment navigationAssignment) { + public @NonNull Node createDependencyClassNode(@NonNull InitUtility utility, @NonNull Node parentNode, @NonNull NavigationAssignment navigationAssignment) { assert parentNode.isClass(); Property property = QVTcoreUtil.getTargetProperty(navigationAssignment); assert property != null; @@ -247,20 +244,20 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N // DomainUsage domainUsage = parentNode.getClassDatumAnalysis().getDomainUsage(); String name = property.getName(); assert name != null; - return createDependencyNode(name, classDatum); + return createDependencyNode(utility, name, classDatum); } - public @NonNull Edge createDependencyEdge(@NonNull Node sourceNode, @NonNull String name, @NonNull Node targetNode) { + public @NonNull Edge createDependencyEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull String name, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); DependencyEdge edge = QVTscheduleFactory.eINSTANCE.createDependencyEdge(); - edge.initialize(edgeRole, sourceNode, name, targetNode); + edge.initialize(edgeRole, utility, sourceNode, name, targetNode); return edge; } - public @NonNull Node createDependencyNode(@NonNull String name, @NonNull ClassDatum classDatum) { + public @NonNull Node createDependencyNode(@NonNull InitUtility utility, @NonNull String name, @NonNull ClassDatum classDatum) { Role nodeRole = Role.PREDICATED; DependencyNode node = QVTscheduleFactory.eINSTANCE.createDependencyNode(); - node.initialize(nodeRole, region, name, classDatum); + node.initialize(nodeRole, region, utility, name, classDatum); return node; } @@ -276,13 +273,12 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return castEdge; } */ - public @NonNull EnumLiteralNode createEnumLiteralNode(boolean isMatched, @NonNull EnumerationLiteral enumValue, @NonNull EnumLiteralExp enumLiteralExp) { + public @NonNull EnumLiteralNode createEnumLiteralNode(@NonNull InitUtility utility, @NonNull EnumerationLiteral enumValue, @NonNull EnumLiteralExp enumLiteralExp) { ClassDatum classDatum = scheduleManager.getClassDatum(enumLiteralExp); String typeName = PrettyPrinter.printType(enumValue); Role nodeRole = getOperationNodePhase(region, enumLiteralExp); EnumLiteralNode enumLiteralNode = QVTscheduleFactory.eINSTANCE.createEnumLiteralNode(); - enumLiteralNode.initialize(nodeRole, region, typeName, classDatum); - enumLiteralNode.setMatched(isMatched); + enumLiteralNode.initialize(nodeRole, region, utility, typeName, classDatum); enumLiteralNode.setEnumValue(enumValue); enumLiteralNode.setOriginatingElement(enumLiteralExp); return enumLiteralNode; @@ -296,7 +292,7 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N // and/or multiple predicates, in which case a hard initializer such as an operation call is preferred, // and then other initializers are checked as predicates using equals edges. // - public @NonNull Edge createEqualsEdge(@NonNull Node sourceNode, @NonNull Node targetNode) { + public @NonNull Edge createEqualsEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { if (!region.isOperationRegion()) { QVTruntimeUtil.errPrintln("Unexpected " + EQUALS_NAME + " edge in " + region + " from " + sourceNode + " to " + targetNode); } @@ -304,89 +300,84 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N // ExpressionEdge edge = QVTscheduleFactory.eINSTANCE.createEqualsEdge(); // edge.initialize(edgeRole, sourceNode, QVTscheduleConstants.EQUALS_NAME, targetNode); // return edge; - return createPredicateEdge(sourceNode, EQUALS_NAME, targetNode); + return createPredicateEdge(utility, sourceNode, EQUALS_NAME, targetNode); } public @NonNull Node createErrorNode(@NonNull String name, @NonNull ClassDatum classDatum) { Role nodeRole = Role.OTHER; ErrorNode node = QVTscheduleFactory.eINSTANCE.createErrorNode(); - node.initialize(nodeRole, region, name, classDatum); + node.initialize(nodeRole, region, InitUtility.NOT_KNOWN, name, classDatum); return node; } - public @NonNull IfNode createIfNode(boolean isMatched, @NonNull String name, @NonNull IfExp ifExp, @NonNull Node @NonNull [] argNodes) { + public @NonNull IfNode createIfNode(@NonNull InitUtility utility, @NonNull String name, @NonNull IfExp ifExp, @NonNull Node @NonNull [] argNodes) { Role nodeRole = getOperationNodePhase(region, ifExp, argNodes); IfNode node = QVTscheduleFactory.eINSTANCE.createIfNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(ifExp)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, scheduleManager.getClassDatum(ifExp)); node.setOriginatingElement(ifExp); return node; } - public @NonNull IfNode createIfNode2(boolean isMatched, @NonNull String name, @NonNull ClassDatum classDatum, @NonNull Node @NonNull [] argNodes) { + public @NonNull IfNode createIfNode2(@NonNull InitUtility utility, @NonNull String name, @NonNull ClassDatum classDatum, @NonNull Node @NonNull [] argNodes) { Role nodeRole = getOperationNodePhase(region, null, argNodes); IfNode node = QVTscheduleFactory.eINSTANCE.createIfNode(); - node.initialize(nodeRole, region, name, classDatum); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, classDatum); return node; } - public @NonNull Node createInputNode(@NonNull Role nodeRole, @NonNull String name, @NonNull ClassDatum classDatum) { + public @NonNull Node createInputNode(@NonNull InitUtility utility, @NonNull Role nodeRole, @NonNull String name, @NonNull ClassDatum classDatum) { InputNode node = QVTscheduleFactory.eINSTANCE.createInputNode(); - node.initialize(nodeRole, region, name, classDatum); + node.initialize(nodeRole, region, utility, name, classDatum); return node; } - public @NonNull Edge createIteratedEdge(@NonNull Node sourceNode, @NonNull Node targetNode) { + public @NonNull Edge createIteratedEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); IteratedEdge edge = QVTscheduleFactory.eINSTANCE.createIteratedEdge(); - edge.initialize(edgeRole, sourceNode, LOOP_ITERATOR_NAME, targetNode); + edge.initialize(edgeRole, utility, sourceNode, LOOP_ITERATOR_NAME, targetNode); return edge; } - public @NonNull VariableNode createIteratorNode(@NonNull VariableDeclaration iterator, @NonNull Node sourceNode) { + public @NonNull VariableNode createIteratorNode(@NonNull InitUtility utility, @NonNull VariableDeclaration iterator, @NonNull Node sourceNode) { Role nodeRole = getNodeRole(sourceNode); IteratorNode node = QVTscheduleFactory.eINSTANCE.createIteratorNode(); - node.initialize(nodeRole, region, getName(iterator), scheduleManager.getClassDatum(iterator)); + node.initialize(nodeRole, region, utility, getName(iterator), scheduleManager.getClassDatum(iterator)); node.initializeVariable(region, iterator); return node; } - public @NonNull Edge createKeyPartEdge(@NonNull Node sourceNode, @NonNull PropertyDatum propertyDatum, @NonNull Node targetNode) { + public @NonNull Edge createKeyPartEdge(@NonNull InitUtility initUtility, @NonNull Node sourceNode, @NonNull PropertyDatum propertyDatum, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); KeyPartEdge edge = QVTscheduleFactory.eINSTANCE.createKeyPartEdge(); edge.setReferredPart(propertyDatum); Property referredProperty = QVTscheduleUtil.getReferredProperty(propertyDatum); String name = "«" + QVTrelationUtil.getName(referredProperty) + "»"; - edge.initialize(edgeRole, sourceNode, name, targetNode); + edge.initialize(edgeRole, initUtility, sourceNode, name, targetNode); return edge; } - public @NonNull Node createKeyedNode(boolean isMatched, @NonNull String name, @NonNull VariableDeclaration templateVariable) { + public @NonNull Node createKeyedNode(@NonNull InitUtility utility, @NonNull String name, @NonNull VariableDeclaration templateVariable) { ClassDatum classDatum = scheduleManager.getClassDatum(templateVariable); KeyedValueNode node = QVTscheduleFactory.eINSTANCE.createKeyedValueNode(); node.setClassDatumValue(classDatum); - node.initialize(Role.REALIZED, region, name, classDatum); + node.initialize(Role.REALIZED, region, utility, name, classDatum); region.addVariableNode(templateVariable, node); - node.setMatched(isMatched); // node.addTypedElement(templateVariable); return node; } - public @NonNull VariableNode createLetVariableNode(@NonNull VariableDeclaration letVariable, @NonNull Node inNode) { + public @NonNull VariableNode createLetVariableNode(@NonNull InitUtility utility, @NonNull VariableDeclaration letVariable, @NonNull Node inNode) { Role nodeRole = getNodeRole(inNode); PatternVariableNode node = QVTscheduleFactory.eINSTANCE.createPatternVariableNode(); - node.initialize(nodeRole, region, getName(letVariable), scheduleManager.getClassDatum(letVariable)); + node.initialize(nodeRole, region, utility, getName(letVariable), scheduleManager.getClassDatum(letVariable)); node.initializeVariable(region, letVariable); - node.setMatched(inNode.isMatched()); return node; } - public @NonNull VariableNode createLoadedStepNode(@NonNull VariableDeclaration stepVariable) { + public @NonNull VariableNode createLoadedStepNode(@NonNull InitUtility utility, @NonNull VariableDeclaration stepVariable) { Role nodeRole = Role.LOADED; PatternVariableNode node = QVTscheduleFactory.eINSTANCE.createPatternVariableNode(); - node.initialize(nodeRole, region, getName(stepVariable), scheduleManager.getClassDatum(stepVariable)); + node.initialize(nodeRole, region, utility, getName(stepVariable), scheduleManager.getClassDatum(stepVariable)); node.initializeVariable(region, stepVariable); - node.setMatched(true); return node; } @@ -399,30 +390,28 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return loadingPartition; } - public @NonNull MapLiteralNode createMapLiteralNode(boolean isMatched, @NonNull String name, @NonNull MapLiteralExp mapLiteralExp, @NonNull Node @NonNull [] partNodes) { + public @NonNull MapLiteralNode createMapLiteralNode(@NonNull InitUtility utility, @NonNull String name, @NonNull MapLiteralExp mapLiteralExp, @NonNull Node @NonNull [] partNodes) { Role nodeRole = getOperationNodePhase(region, mapLiteralExp, partNodes); MapLiteralNode node = QVTscheduleFactory.eINSTANCE.createMapLiteralNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(mapLiteralExp)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, scheduleManager.getClassDatum(mapLiteralExp)); node.setOriginatingElement(mapLiteralExp); return node; } - public @NonNull Edge createMapPartEdge(@NonNull Node sourceNode, @NonNull MapLiteralPart mapPart, @NonNull Node targetNode) { + public @NonNull Edge createMapPartEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull MapLiteralPart mapPart, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); MapPartEdge edge = QVTscheduleFactory.eINSTANCE.createMapPartEdge(); edge.setReferredPart(mapPart); String label = "«" + mapPart.toString() + "»"; - edge.initialize(edgeRole, sourceNode, label, targetNode); + edge.initialize(edgeRole, utility, sourceNode, label, targetNode); return edge; } - public @NonNull Node createMapPartNode(boolean isMatched, @NonNull String name, @NonNull MapLiteralPart mapLiteralPart, @NonNull Node @NonNull [] argNodes) { + public @NonNull Node createMapPartNode(@NonNull InitUtility utility, @NonNull String name, @NonNull MapLiteralPart mapLiteralPart, @NonNull Node @NonNull [] argNodes) { TypedElement typedElement = QVTbaseUtil.getOwnedValue(mapLiteralPart); // FIXME delete this Role nodeRole = getOperationNodePhase(region, typedElement, argNodes); MapPartNode node = QVTscheduleFactory.eINSTANCE.createMapPartNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(typedElement)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, scheduleManager.getClassDatum(typedElement)); node.setOriginatingElement(mapLiteralPart); return node; } @@ -436,15 +425,15 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return mergedPartition; } - public @NonNull NavigableEdge createNavigationEdge(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { + public @NonNull NavigableEdge createNavigationEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { Role phase = mergeToLessKnownPhase(getNodeRole(sourceNode), getNodeRole(targetNode)); - return createNavigationEdge(phase, sourceNode, source2targetProperty, targetNode, isPartial); + return createNavigationEdge(phase, utility, sourceNode, source2targetProperty, targetNode, isPartial); } - public @NonNull NavigableEdge createNavigationEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { + public @NonNull NavigableEdge createNavigationEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { NavigationEdge edge = QVTscheduleFactory.eINSTANCE.createNavigationEdge(); - edge.initialize(edgeRole, sourceNode, source2targetProperty.getName(), targetNode); - edge.initializeProperty(source2targetProperty, isPartial); + edge.initialize(edgeRole, utility, sourceNode, source2targetProperty.getName(), targetNode); + edge.initializeProperty(source2targetProperty, utility, isPartial); return edge; } @@ -457,7 +446,7 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return nonPartition; } - public @NonNull Node createNullLiteralNode(boolean isMatched, @Nullable NullLiteralExp nullLiteralExp) { + public @NonNull Node createNullLiteralNode(@NonNull InitUtility utility, @Nullable NullLiteralExp nullLiteralExp) { Role nodeRole = Role.CONSTANT; ClassDatum classDatum; if (nullLiteralExp != null) { @@ -467,25 +456,23 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N classDatum = scheduleManager.getOclVoidClassDatum(); } NullLiteralNode node = QVTscheduleFactory.eINSTANCE.createNullLiteralNode(); - node.initialize(nodeRole, region, "«null»", classDatum); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, "«null»", classDatum); if (nullLiteralExp != null) { node.setOriginatingElement(nullLiteralExp); } return node; } - public @NonNull NumericLiteralNode createNumericLiteralNode(boolean isMatched, @NonNull Number numericValue, @NonNull NumericLiteralExp numericLiteralExp) { + public @NonNull NumericLiteralNode createNumericLiteralNode(@NonNull InitUtility utility, @NonNull Number numericValue, @NonNull NumericLiteralExp numericLiteralExp) { Role nodeRole = getOperationNodePhase(region, numericLiteralExp); NumericLiteralNode node = QVTscheduleFactory.eINSTANCE.createNumericLiteralNode(); - node.initialize(nodeRole, region, numericValue.toString(), scheduleManager.getClassDatum(numericLiteralExp)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, numericValue.toString(), scheduleManager.getClassDatum(numericLiteralExp)); node.setNumericValue(numericValue); node.setOriginatingElement(numericLiteralExp); return node; } - public @NonNull VariableNode createOldNode(@NonNull VariableDeclaration variable) { + public @NonNull VariableNode createOldNode(@NonNull InitUtility utility, @NonNull VariableDeclaration variable) { Role nodeRole; boolean isThis = QVTbaseUtil.isThis(variable); if (isThis) { @@ -499,9 +486,9 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N } ClassDatum classDatum = scheduleManager.getClassDatum(variable); PatternVariableNode node = QVTscheduleFactory.eINSTANCE.createPatternVariableNode(); - node.initialize(nodeRole, region, getName(variable), classDatum); + node.initialize(nodeRole, region, utility, getName(variable), classDatum); node.initializeVariable(region, variable); - node.setMatched(QVTrelationUtil.isRequired(variable)); + // node.setMatched(QVTrelationUtil.isRequired(variable)); if (isThis) { node.setThis(); node.setHead(); @@ -509,33 +496,31 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return node; } - public @NonNull OperationCallNode createOperationCallNode(boolean isMatched, @Nullable String nameHint, @NonNull Operation operation, @NonNull TypedElement callExpOrCollectionTemplateExp, @NonNull Node ... argNodes) { + public @NonNull OperationCallNode createOperationCallNode(@NonNull InitUtility utility, @Nullable String nameHint, @NonNull Operation operation, @NonNull TypedElement callExpOrCollectionTemplateExp, @NonNull Node ... argNodes) { String name = nameHint; if (name == null) { name = QVTbaseUtil.getName(operation); } Role nodeRole = getOperationNodePhase(region, callExpOrCollectionTemplateExp, argNodes); OperationCallNode node = QVTscheduleFactory.eINSTANCE.createOperationCallNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(callExpOrCollectionTemplateExp)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, scheduleManager.getClassDatum(callExpOrCollectionTemplateExp)); node.setOriginatingElement(callExpOrCollectionTemplateExp); node.setReferredOperation(operation); return node; } - public @NonNull OperationCallNode createOperationCallNode2(@NonNull Role nodeRole, boolean isMatched, @Nullable String nameHint, @NonNull Operation operation, @NonNull ClassDatum classDatum, @NonNull Node ... argNodes) { + public @NonNull OperationCallNode createOperationCallNode2(@NonNull Role nodeRole, @NonNull InitUtility utility, @Nullable String nameHint, @NonNull Operation operation, @NonNull ClassDatum classDatum, @NonNull Node ... argNodes) { String name = nameHint; if (name == null) { name = QVTbaseUtil.getName(operation); } assert nodeRole != null; OperationCallNode node = QVTscheduleFactory.eINSTANCE.createOperationCallNode(); - node.initialize(nodeRole, region, name, classDatum); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, classDatum); node.setReferredOperation(operation); return node; } - public @NonNull Edge createOperationParameterEdge(@NonNull Node sourceNode, @NonNull Parameter parameter, int parameterIndex, @NonNull Node targetNode) { + public @NonNull Edge createOperationParameterEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Parameter parameter, int parameterIndex, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); String name; OperationParameterEdge edge = QVTscheduleFactory.eINSTANCE.createOperationParameterEdge(); @@ -550,21 +535,21 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N name = "«" + parameter.getName() + "»"; } // edge.setReferredObject(typeOrParameter); // FIXME redundant - edge.initialize(edgeRole, sourceNode, name, targetNode); + edge.initialize(edgeRole, utility, sourceNode, name, targetNode); return edge; } - public @NonNull Edge createOperationSelfEdge(@NonNull Node sourceNode, @NonNull Type type, @NonNull Node targetNode) { + public @NonNull Edge createOperationSelfEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Type type, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); OperationSelfEdge edge = QVTscheduleFactory.eINSTANCE.createOperationSelfEdge(); edge.setReferredType(type); String name = "«" + PivotConstants.SELF_NAME + "»"; // edge.setReferredObject(typeOrParameter); // FIXME redundant - edge.initialize(edgeRole, sourceNode, name, targetNode); + edge.initialize(edgeRole, utility, sourceNode, name, targetNode); return edge; } - public @NonNull Node createPatternNode(@NonNull Role nodeRole, @NonNull Node sourceNode, @NonNull Property source2targetProperty, boolean isMatched) { + public @NonNull Node createPatternNode(@NonNull Role nodeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Property source2targetProperty) { assert sourceNode.isClass(); org.eclipse.ocl.pivot.Class type = (org.eclipse.ocl.pivot.Class)source2targetProperty.getType(); assert type != null; @@ -575,15 +560,14 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N String name = source2targetProperty.getName(); assert name != null; PatternTypedNode node = QVTscheduleFactory.eINSTANCE.createPatternTypedNode(); - node.initialize(nodeRole, region, name, classDatum); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, classDatum); return node; } - public @NonNull Edge createPredicateEdge(@NonNull Node sourceNode, @Nullable String name, @NonNull Node targetNode) { + public @NonNull Edge createPredicateEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @Nullable String name, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); PredicateEdge edge = QVTscheduleFactory.eINSTANCE.createPredicateEdge(); - edge.initialize(edgeRole, sourceNode, name, targetNode); + edge.initialize(edgeRole, utility, sourceNode, name, targetNode); return edge; } @@ -596,65 +580,63 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return forwardEdge; } */ - public @NonNull Node createPredicatedNode(@NonNull String name, @NonNull ClassDatum classDatum, boolean isMatched) { + public @NonNull Node createPredicatedNode(@NonNull InitUtility utility, @NonNull String name, @NonNull ClassDatum classDatum) { PatternTypedNode node = QVTscheduleFactory.eINSTANCE.createPatternTypedNode(); - node.initialize(Role.PREDICATED, region, name, classDatum); - node.setMatched(isMatched); + node.initialize(Role.PREDICATED, region, utility, name, classDatum); return node; } - public @NonNull Node createPredicatedStepNode(@NonNull Node typedNode, boolean isMatched) { + public @NonNull Node createPredicatedStepNode(@NonNull InitUtility utility, @NonNull Node typedNode) { String name = getName(typedNode); ClassDatum classDatum = getClassDatum(typedNode); - return createPredicatedNode(name, classDatum, isMatched); + return createPredicatedNode(utility, name, classDatum); } /** * Create a predicated source2targetProperty success edge from sourceNode to a true/false BooleanValueNode. */ - public @NonNull SuccessEdge createPredicatedSuccess(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @Nullable Boolean isSuccess) { + public @NonNull SuccessEdge createPredicatedSuccess(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Property source2targetProperty, @Nullable Boolean isSuccess) { Node successNode; if (isSuccess != null) { - successNode = createBooleanLiteralNode(isSuccess); + successNode = createBooleanLiteralNode(utility, isSuccess, null); } else { - successNode = createPredicatedNode("matches", scheduleManager.getBooleanClassDatum(), false); // FIXME isMatched + successNode = createPredicatedNode(utility, "matches", scheduleManager.getBooleanClassDatum()); } SuccessEdge edge = QVTscheduleFactory.eINSTANCE.createSuccessEdge(); - edge.initialize(Role.PREDICATED, sourceNode, source2targetProperty.getName(), successNode); - edge.initializeProperty(source2targetProperty, false); + edge.initialize(Role.PREDICATED, utility, sourceNode, source2targetProperty.getName(), successNode); + edge.initializeProperty(source2targetProperty, utility, false); return edge; } - public @NonNull Node createRealizedDataTypeNode(@NonNull Node sourceNode, @NonNull Property source2targetProperty) { + public @NonNull Node createRealizedDataTypeNode(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Property source2targetProperty) { Role nodeRole = Role.REALIZED; - return createPatternNode(nodeRole, sourceNode, source2targetProperty, sourceNode.isMatched()); + return createPatternNode(nodeRole, utility, sourceNode, source2targetProperty); } - public @NonNull Edge createRealizedIncludesEdge(@NonNull Node sourceNode, @NonNull Node targetNode) { + public @NonNull Edge createRealizedIncludesEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { Role edgeRole = Role.REALIZED; ExpressionEdge edge = QVTscheduleFactory.eINSTANCE.createIncludesEdge(); - edge.initialize(edgeRole, sourceNode, INCLUDES_NAME, targetNode); + edge.initialize(edgeRole, utility, sourceNode, INCLUDES_NAME, targetNode); return edge; } - public @NonNull NavigableEdge createRealizedNavigationEdge(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { + public @NonNull NavigableEdge createRealizedNavigationEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Property source2targetProperty, @NonNull Node targetNode, boolean isPartial) { Role edgeRole = Role.REALIZED; NavigationEdge forwardEdge = QVTscheduleFactory.eINSTANCE.createNavigationEdge(); - forwardEdge.initialize(edgeRole, sourceNode, source2targetProperty.getName(), targetNode); - forwardEdge.initializeProperty(source2targetProperty, isPartial); + forwardEdge.initialize(edgeRole, utility, sourceNode, source2targetProperty.getName(), targetNode); + forwardEdge.initializeProperty(source2targetProperty, utility, isPartial); return forwardEdge; } - public @NonNull VariableNode createRealizedNode(@NonNull String name, @NonNull ClassDatum classDatum, boolean isMatched) { + public @NonNull VariableNode createRealizedNode(@NonNull InitUtility utility, @NonNull String name, @NonNull ClassDatum classDatum) { PatternVariableNode node = QVTscheduleFactory.eINSTANCE.createPatternVariableNode(); - node.initialize(Role.REALIZED, region, name, classDatum); - node.setMatched(isMatched); + node.initialize(Role.REALIZED, region, utility, name, classDatum); return node; } - public @NonNull VariableNode createRealizedStepNode(@NonNull VariableDeclaration stepVariable) { - VariableNode node = createRealizedNode(getName(stepVariable), scheduleManager.getClassDatum(stepVariable), true); + public @NonNull VariableNode createRealizedStepNode(@NonNull InitUtility initUtility, @NonNull VariableDeclaration stepVariable) { + VariableNode node = createRealizedNode(initUtility, getName(stepVariable), scheduleManager.getClassDatum(stepVariable)); node.initializeVariable(region, stepVariable); return node; } @@ -663,20 +645,20 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N * Create a realized source2targetProperty success edge from sourceNode to a true/false BooleanValueNode if isSuccesss is non-null, * else to a SuccessNode. */ - public @NonNull SuccessEdge createRealizedSuccess(@NonNull Node sourceNode, @NonNull Property source2targetProperty, @Nullable Boolean isSuccess) { + public @NonNull SuccessEdge createRealizedSuccess(@NonNull InitUtility initUtility, @NonNull Node sourceNode, @NonNull Property source2targetProperty, @Nullable Boolean isSuccess) { ClassDatum classDatum = scheduleManager.getBooleanClassDatum(); Node node; if (isSuccess != null) { - node = createBooleanLiteralNode(isSuccess); + node = createBooleanLiteralNode(initUtility, isSuccess, null); } else { SuccessNode successNode = QVTscheduleFactory.eINSTANCE.createSuccessNode(); - successNode.initialize(Role.REALIZED, region, "«success»", classDatum); + successNode.initialize(Role.REALIZED, region, InitUtility.SUCCESS, "«success»", classDatum); node = successNode; } SuccessEdge edge = QVTscheduleFactory.eINSTANCE.createSuccessEdge(); - edge.initialize(Role.REALIZED, sourceNode, source2targetProperty.getName(), node); - edge.initializeProperty(source2targetProperty, false); + edge.initialize(Role.REALIZED, initUtility, sourceNode, source2targetProperty.getName(), node); + edge.initializeProperty(source2targetProperty, initUtility, false); return edge; } @@ -697,25 +679,24 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return edge; } */ - public @NonNull ShadowNode createShadowNode(boolean isMatched, @NonNull String name, @NonNull ShadowExp shadowExp, @NonNull Node @NonNull [] partNodes) { + public @NonNull ShadowNode createShadowNode(@NonNull InitUtility utility, @NonNull String name, @NonNull ShadowExp shadowExp, @NonNull Node @NonNull [] partNodes) { Role nodeRole = getOperationNodePhase(region, shadowExp, partNodes); ShadowNode node = QVTscheduleFactory.eINSTANCE.createShadowNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(shadowExp)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, scheduleManager.getClassDatum(shadowExp)); node.setOriginatingElement(shadowExp); return node; } - public @NonNull Edge createShadowPartEdge(@NonNull Node sourceNode, @NonNull ShadowPart shadowPart, @NonNull Node targetNode) { + public @NonNull Edge createShadowPartEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull ShadowPart shadowPart, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); ShadowPartEdge edge = QVTscheduleFactory.eINSTANCE.createShadowPartEdge(); edge.setReferredPart(shadowPart); String label = "«" + shadowPart.getName() + "»"; - edge.initialize(edgeRole, sourceNode, label, targetNode); + edge.initialize(edgeRole, utility, sourceNode, label, targetNode); return edge; } - public @NonNull Node createStepNode(@NonNull String name, @NonNull CallExp callExp, @NonNull Node sourceNode, boolean isMatched) { + public @NonNull Node createStepNode(@NonNull InitUtility utility, @NonNull String name, @NonNull CallExp callExp, @NonNull Node sourceNode) { DomainUsage domainUsage = scheduleManager.getDomainUsage(callExp); boolean isMiddleOrOutput = scheduleManager.isOutputInRule(QVTbaseUtil.getContainingRule(callExp), callExp) || domainUsage.isMiddle(); boolean isDirty = false; @@ -726,8 +707,7 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N Role phase = /*sourceNode.isPredicated() ||*/ isMiddleOrOutput || isDirty ? Role.PREDICATED : Role.LOADED; Role stepNodeRole = phase; PatternTypedNode node = QVTscheduleFactory.eINSTANCE.createPatternTypedNode(); - node.initialize(stepNodeRole, region, name, scheduleManager.getClassDatum(callExp)); - node.setMatched(isMatched); + node.initialize(stepNodeRole, region, utility, name, scheduleManager.getClassDatum(callExp)); node.setOriginatingElement(callExp); return node; } @@ -740,41 +720,38 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N return edge; } */ - public @NonNull StringLiteralNode createStringLiteralNode(boolean isMatched, @NonNull String stringValue, @NonNull StringLiteralExp stringLiteralExp) { + public @NonNull StringLiteralNode createStringLiteralNode(@NonNull InitUtility utility, @NonNull String stringValue, @NonNull StringLiteralExp stringLiteralExp) { Role nodeRole = getOperationNodePhase(region, stringLiteralExp); StringLiteralNode node = QVTscheduleFactory.eINSTANCE.createStringLiteralNode(); - node.initialize(nodeRole, region, stringValue, scheduleManager.getClassDatum(stringLiteralExp)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, stringValue, scheduleManager.getClassDatum(stringLiteralExp)); node.setStringValue(stringValue); node.setOriginatingElement(stringLiteralExp); return node; } - public @NonNull TupleLiteralNode createTupleLiteralNode(boolean isMatched, @NonNull String name, @NonNull TupleLiteralExp tupleLiteralExp, @NonNull Node @NonNull [] partNodes) { + public @NonNull TupleLiteralNode createTupleLiteralNode(@NonNull InitUtility utility, @NonNull String name, @NonNull TupleLiteralExp tupleLiteralExp, @NonNull Node @NonNull [] partNodes) { Role nodeRole = getOperationNodePhase(region, tupleLiteralExp, partNodes); TupleLiteralNode node = QVTscheduleFactory.eINSTANCE.createTupleLiteralNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(tupleLiteralExp)); - node.setMatched(isMatched); + node.initialize(nodeRole, region, utility, name, scheduleManager.getClassDatum(tupleLiteralExp)); node.setOriginatingElement(tupleLiteralExp); return node; } - public @NonNull Edge createTuplePartEdge(@NonNull Node sourceNode, @NonNull TupleLiteralPart tuplePart, @NonNull Node targetNode) { + public @NonNull Edge createTuplePartEdge(@NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull TupleLiteralPart tuplePart, @NonNull Node targetNode) { Role edgeRole = getNodeRole(sourceNode); TuplePartEdge edge = QVTscheduleFactory.eINSTANCE.createTuplePartEdge(); edge.setReferredPart(tuplePart); String label = "«" + tuplePart.getName() + "»"; - edge.initialize(edgeRole, sourceNode, label, targetNode); + edge.initialize(edgeRole, utility, sourceNode, label, targetNode); return edge; } - public @NonNull TypeLiteralNode createTypeLiteralNode(boolean isMatched, @NonNull Type typeValue, @NonNull TypeExp typeExp) { + public @NonNull TypeLiteralNode createTypeLiteralNode(@NonNull InitUtility utility, @NonNull Type typeValue, @NonNull TypeExp typeExp) { ClassDatum classDatum = scheduleManager.getClassDatum(typeExp); // String typeName = PrettyPrinter.printType(QVTscheduleUtil.getCompleteClass(classDatum)); Role nodeRole = getOperationNodePhase(region, typeExp); TypeLiteralNode typeLiteralNode = QVTscheduleFactory.eINSTANCE.createTypeLiteralNode(); - typeLiteralNode.initialize(nodeRole, region, String.valueOf(typeValue), classDatum); - typeLiteralNode.setMatched(isMatched); + typeLiteralNode.initialize(nodeRole, region, utility, String.valueOf(typeValue), classDatum); typeLiteralNode.setTypeValue(typeValue); typeLiteralNode.setOriginatingElement(typeExp); return typeLiteralNode; @@ -783,7 +760,7 @@ public class RegionHelper<R extends Region> extends QVTscheduleUtil implements N public @NonNull Node createUnknownNode(@NonNull String name, @NonNull TypedElement typedElement) { Role nodeRole = Role.OTHER; UnknownNode node = QVTscheduleFactory.eINSTANCE.createUnknownNode(); - node.initialize(nodeRole, region, name, scheduleManager.getClassDatum(typedElement)); + node.initialize(nodeRole, region, InitUtility.NOT_KNOWN, name, scheduleManager.getClassDatum(typedElement)); return node; } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RuleAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RuleAnalysis.java index f3ef17ed4..d39505b52 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RuleAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RuleAnalysis.java @@ -37,6 +37,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.Edge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.RuleRegion; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; import com.google.common.collect.Lists; @@ -63,7 +64,7 @@ public abstract class RuleAnalysis extends RegionHelper<@NonNull RuleRegion> protected final @NonNull AbstractTransformationAnalysis transformationAnalysis; protected final @NonNull Rule rule; - protected final @NonNull ExpressionSynthesizer unconditionalExpressionSynthesizer; + protected final @NonNull ExpressionSynthesizer rootExpressionSynthesizer; private @Nullable Rule2TraceGroup relation2traceGroup = null; @@ -76,7 +77,7 @@ public abstract class RuleAnalysis extends RegionHelper<@NonNull RuleRegion> super(transformationAnalysis.getScheduleManager(), ruleRegion); this.rule = QVTscheduleUtil.getReferredRule(ruleRegion); this.transformationAnalysis = transformationAnalysis; - this.unconditionalExpressionSynthesizer = scheduleManager.createUnconditionalExpressionSynthesizer(this); + this.rootExpressionSynthesizer = scheduleManager.createRootExpressionSynthesizer(this); // assert !rule.isIsAbstract() == scheduleManager.getScheduleModel().getOwnedMappingRegions().contains(ruleRegion); } @@ -92,7 +93,7 @@ public abstract class RuleAnalysis extends RegionHelper<@NonNull RuleRegion> if (dependencyHeadNodes == null) { dependencyHeadNodes = new ArrayList<>(); } - Node dependencyHeadNode = createDependencyNode("«extra-" + (dependencyHeadNodes.size()+1) + "»", classDatum); + Node dependencyHeadNode = createDependencyNode(InitUtility.DEPENDENCY, "«extra-" + (dependencyHeadNodes.size()+1) + "»", classDatum); dependencyHeadNode.setHead(); dependencyHeadNodes.add(dependencyHeadNode); return dependencyHeadNode; @@ -176,11 +177,11 @@ public abstract class RuleAnalysis extends RegionHelper<@NonNull RuleRegion> // boolean allMatched = false; // True if all outgoing edges of sourceNode are matched. Node sourceNode = QVTscheduleUtil.getSourceNode(edge); - if (sourceNode.isMatched()) { + if (!sourceNode.isConditional()) { allMatched = true; for (@NonNull Edge outgoingEdge : QVTscheduleUtil.getOutgoingEdges(sourceNode)) { Node targetNode = QVTscheduleUtil.getTargetNode(outgoingEdge); - if (!targetNode.isMatched()) { + if (targetNode.isConditional()) { allMatched = false; break; } @@ -207,8 +208,8 @@ public abstract class RuleAnalysis extends RegionHelper<@NonNull RuleRegion> rewriteCastEdgeAsMergedMultiCompleteClass(sourceNode, allCompleteClasses); } else { - assert !edge.isMatched(); - unconditionalExpressionSynthesizer.getExpressionSynthesizer(false).rewriteCastEdgeAsOclAsType((CastEdge)edge); + assert !edge.isUnconditional(); + rootExpressionSynthesizer.getExpressionSynthesizer(/*Node.Utility.CONDITIONAL*/edge.getInitUtility()).rewriteCastEdgeAsOclAsType((CastEdge)edge); } assert edge.eContainer() == null; assert edge.getSourceNode() == null; @@ -238,7 +239,9 @@ public abstract class RuleAnalysis extends RegionHelper<@NonNull RuleRegion> ClassDatum mergedClassDatum = scheduleManager.getClassDatum(typedModel, newCompleteClasses); sourceNode.setClassDatum(mergedClassDatum); for (@NonNull Edge sourceOutgoingEdge : Lists.newArrayList(QVTscheduleUtil.getOutgoingEdges(sourceNode))) { - CompilerUtil.migrateCastEdgeTargetContents((CastEdge)sourceOutgoingEdge, sourceNode); + if (sourceOutgoingEdge instanceof CastEdge) { + CompilerUtil.migrateCastEdgeTargetContents((CastEdge)sourceOutgoingEdge, sourceNode); + } } } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RuleHeadAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RuleHeadAnalysis.java index 6430e017b..cf22f60a6 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RuleHeadAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/RuleHeadAnalysis.java @@ -151,7 +151,7 @@ public class RuleHeadAnalysis extends HeadAnalysis private @NonNull Map<@NonNull Node, @NonNull Set<@NonNull Node>> computeOldTargetFromSources() { Map<@NonNull Node, @NonNull Set<@NonNull Node>> targetFromSources = new HashMap<>(); for (@NonNull Node targetNode : QVTscheduleUtil.getOwnedNodes(mappingRegion)) { - if (targetNode.isMatched() && !targetNode.isConstant() && !targetNode.isOperation()) { // Operations are traversed by derived head group analysis + if (targetNode.isUnconditional() && !targetNode.isConstant() && !targetNode.isOperation()) { // Operations are traversed by derived head group analysis if (targetNode.isLoaded() || targetNode.isChecked()) { Set<@NonNull Node> sources = Sets.newHashSet(targetNode); targetFromSources.put(targetNode, sources); @@ -159,7 +159,7 @@ public class RuleHeadAnalysis extends HeadAnalysis if (edge instanceof NavigationEdge) { if (!edge.isRealized() && !((NavigationEdge)edge).isPartial()) { Node sourceNode = edge.getEdgeSource(); - if (sourceNode.isMatched() && !sourceNode.isConstant() && !sourceNode.isOperation()) { + if (sourceNode.isUnconditional() && !sourceNode.isConstant() && !sourceNode.isOperation()) { if (sourceNode.isLoaded() || sourceNode.isChecked()) { sources.add(sourceNode); } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/ScheduleManager.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/ScheduleManager.java index a896794ad..c49415146 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/ScheduleManager.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/ScheduleManager.java @@ -85,10 +85,10 @@ public interface ScheduleManager */ boolean computeIsPartial(@NonNull Node targetNode, @NonNull Property property); @NonNull ConnectionManager createConnectionManager(@NonNull ProblemHandler problemHandler, @NonNull LoadingRegionAnalysis loadingRegionAnalysis); + @NonNull ExpressionSynthesizer createRootExpressionSynthesizer(@NonNull RuleAnalysis ruleAnalysis); @NonNull RuleAnalysis createRuleAnalysis(@NonNull AbstractTransformationAnalysis transformationAnalysis, @NonNull Rule asRule); @NonNull Rule2TraceGroup createRule2TraceGroup(@NonNull Transformation2TracePackage transformation2TracePackage, @NonNull Rule rule); @NonNull Transformation2TracePackage createTransformation2TracePackage(@NonNull Transformation transformation); - @NonNull ExpressionSynthesizer createUnconditionalExpressionSynthesizer(@NonNull RuleAnalysis ruleAnalysis); @NonNull Iterable<@NonNull PropertyDatum> getAllPropertyDatums(@NonNull ClassDatum classDatum); @NonNull Iterable<@NonNull RuleRegion> gatherRuleRegions(); @NonNull PropertyDatum getBasePropertyDatum(@NonNull PropertyDatum propertyDatum); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/UtilityAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/UtilityAnalysis.java deleted file mode 100644 index 7a5e50314..000000000 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/UtilityAnalysis.java +++ /dev/null @@ -1,366 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2015, 2019 Willink Transformations and others. - * All rights reserved. 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 - * http://www.eclipse.org/legal/epl-v20.html - * - * Contributors: - * E.D.Willink - Initial API and implementation - *******************************************************************************/ -package org.eclipse.qvtd.compiler.internal.qvtb2qvts; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import org.eclipse.jdt.annotation.NonNull; -import org.eclipse.jdt.annotation.Nullable; -import org.eclipse.ocl.pivot.Parameter; -import org.eclipse.ocl.pivot.utilities.NameUtil; -import org.eclipse.qvtd.pivot.qvtschedule.Edge; -import org.eclipse.qvtd.pivot.qvtschedule.NavigationEdge; -import org.eclipse.qvtd.pivot.qvtschedule.Node; -import org.eclipse.qvtd.pivot.qvtschedule.Node.Utility; -import org.eclipse.qvtd.pivot.qvtschedule.OperationParameterEdge; -import org.eclipse.qvtd.pivot.qvtschedule.Region; -import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; -import org.eclipse.qvtd.runtime.utilities.QVTruntimeLibraryHelper; -import org.eclipse.qvtd.runtime.utilities.QVTruntimeUtil; - -import com.google.common.collect.Sets; - -/** - * UtilityAnalysis is a helper that assigns a Utility value to each Region node. - * - * FIXME a QVTrelationUtilityAnalysis might be simpler than this QVTc chain version. - * - * FIXME For QVTr at least, it should be possible to assign the correct Utility during Node construction - * obviating the need for a later assignUtilities and the inconvenience of not being able to use the utility - * beteem construction and assignUtilities. - */ -public class UtilityAnalysis -{ - public static void assignUtilities(@NonNull ScheduleManager scheduleManager, @NonNull Region region) { - new UtilityAnalysis(scheduleManager, region).assignUtilities(); - } - - protected final @NonNull ScheduleManager scheduleManager; - protected final @NonNull Region region; - protected final @NonNull QVTruntimeLibraryHelper qvtbaseLibraryHelper; - - private /*@LazyNonNull*/ @Nullable List<@NonNull Node> stronglyMatchedNodes = null; - private /*@LazyNonNull*/ @Nullable List<@NonNull Node> unconditionalNodes = null; - private /*@LazyNonNull*/ @Nullable List<@NonNull Node> conditionalNodes = null; - // private /*@LazyNonNull*/ @Nullable List<@NonNull Node> dependencyNodes = null; - private /*@LazyNonNull*/ @Nullable List<@NonNull Node> deadNodes = null; - - protected UtilityAnalysis(@NonNull ScheduleManager scheduleManager, @NonNull Region region) { - this.scheduleManager = scheduleManager; - this.region = region; - this.qvtbaseLibraryHelper = scheduleManager.getQVTruntimeLibraryHelper(); - } - - protected void assignUtilities() { // FIXME remove assertions after 1-Jan-2017 - Iterable<@NonNull Node> headNodes = QVTscheduleUtil.getHeadNodes(region); - Node dispatchNode = computeDispatchNode(); - Set<@NonNull Node> traceNodes = computeTraceNodes(headNodes); - Set<@NonNull Node> stronglyMatchedNodes = computeStronglyMatchedNodes(headNodes); - Set<@NonNull Node> unconditionalNodes = computeUnconditionalNodes(headNodes); - Set<@NonNull Node> conditionalNodes = computeConditionalNodes(unconditionalNodes); - // Set<@NonNull Node> dependencyNodes = computeDependencyNodes(headNodes); - Set<@NonNull Node> deadNodes = null; - // - for (@NonNull Node node : QVTscheduleUtil.getOwnedNodes(region)) { - Node.Utility oldUtility = node.basicGetUtility(); - if (dispatchNode == node) { - node.setUtility(Node.Utility.DISPATCH); - } - else if (traceNodes.contains(node)) { - node.setUtility(Node.Utility.TRACE); - } - else if (stronglyMatchedNodes.contains(node)) { - node.setUtility(Node.Utility.STRONGLY_MATCHED); - //FIXME assert unconditionalNodes.contains(node); - if (!unconditionalNodes.contains(node)) { - QVTruntimeUtil.errPrintln(node + " is not unconditional in " + this); - } - // assert !dependencyNodes.contains(node); - } - else if (unconditionalNodes.contains(node) && !node.isDependency()) { - node.setUtility(Node.Utility.WEAKLY_MATCHED); - // assert !dependencyNodes.contains(node); - } - else if (conditionalNodes.contains(node)) { - node.setUtility(Node.Utility.CONDITIONAL); - // assert !dependencyNodes.contains(node); - } - else if (node.isDependency()) { - node.setUtility(Node.Utility.DEPENDENCY); - } - else if (node.isComposed()) { - node.setUtility(Node.Utility.COMPOSED); - } - else { - System.out.println("Dead node in " + this + " : " + node); - if (deadNodes == null) { - deadNodes = new HashSet<>(); - } - deadNodes.add(node); - node.setUtility(Node.Utility.DEAD); - toString(); - } - Node.Utility newUtility = node.getUtility(); - if (oldUtility != null) { - assert oldUtility == newUtility; - } - } - if (deadNodes != null) { - this.deadNodes = new ArrayList<>(deadNodes); - Collections.sort(this.deadNodes, NameUtil.NAMEABLE_COMPARATOR); - } - /* for (@NonNull Node node : getNodes()) { - boolean isMatched = node.isMatched(); - boolean isUnconditional = node.isUnconditional(); - boolean isRequired = node.isRequired(); - boolean isPattern = node.isPattern(); - if (isMatched != (isUnconditional && isPattern)) { - System.out.println("Inconsistently isMatched in " + this + " : " + node); - } - } */ - } - - private boolean canBeStronglyMatched(@NonNull Node node) { - if (node.isPattern()) { - return true; - } - if (node.isConstant()) { - return true; - } - return false; - } - - private boolean canBeUnconditional(@NonNull Node node) { - if (node.isIterator()) { - return false; - } - if (node.isOperation()) { - return true; - } - if (node.isPattern()) { - return true; - } - if (node.isSuccess()) { - return true; - } - return false; - } - - /** - * Any node with an edge to an unconditional node that is not itself unconditional must be conditional. - */ - private @NonNull Set<@NonNull Node> computeConditionalNodes(@NonNull Set<@NonNull Node> unconditionalNodes) { - Set<@NonNull Node> conditionalNodes = new HashSet<>(); - Set<@NonNull Node> moreNodes = unconditionalNodes; - while (moreNodes.size() > 0) { - Set<@NonNull Node> moreMoreNodes = new HashSet<>(); - for (@NonNull Node node : moreNodes) { - for (@NonNull Edge incomingEdge : QVTscheduleUtil.getIncomingEdges(node)) { - Node sourceNode = incomingEdge.getEdgeSource(); - if (!unconditionalNodes.contains(sourceNode) && conditionalNodes.add(sourceNode)) { - moreMoreNodes.add(sourceNode); - } - } - for (@NonNull Edge outgoingEdge : QVTscheduleUtil.getOutgoingEdges(node)) { - Node targetNode = outgoingEdge.getEdgeTarget(); - if (!unconditionalNodes.contains(targetNode) && conditionalNodes.add(targetNode)) { - moreMoreNodes.add(targetNode); - } - } - } - if (moreMoreNodes.size() <= 0) { - break; - } - moreNodes = moreMoreNodes; - } - this.conditionalNodes = new ArrayList<>(conditionalNodes); - Collections.sort(this.conditionalNodes, NameUtil.NAMEABLE_COMPARATOR); - return conditionalNodes; - } - - private @Nullable Node computeDispatchNode() { - Node dispatchNode = null; - for (@NonNull Node node : QVTscheduleUtil.getOwnedNodes(region)) { - if (node.isPredicated()) { - if (node.basicGetUtility() == Utility.DISPATCH) { - assert dispatchNode == null; // No double dispatch - dispatchNode = node; - } - } - } - return dispatchNode; - } - - private @NonNull Set<@NonNull Node> computeStronglyMatchedNodes(@NonNull Iterable<@NonNull Node> headNodes) { - Set<@NonNull Node> stronglyMatchedNodes = new HashSet<>(); - for (@NonNull Node headNode : headNodes) { - if (!headNode.isDependency()) { - stronglyMatchedNodes.add(headNode); - } - } - // for (@NonNull Node node : QVTscheduleUtil.getOwnedNodes(region)) { - // if (node.isConstant()) { - // stronglyMatchedNodes.add(node); - // } - // } - Set<@NonNull Node> moreStronglyMatchedNodes = new HashSet<>(stronglyMatchedNodes); - while (moreStronglyMatchedNodes.size() > 0) { - Set<@NonNull Node> moreMoreNodes = new HashSet<>(); - for (@NonNull Node sourceNode : moreStronglyMatchedNodes) { - for (@NonNull Edge edge : QVTscheduleUtil.getOutgoingEdges(sourceNode)) { - if (edge.isNavigation()) { - NavigationEdge navigationEdge = (NavigationEdge)edge; - Node targetNode = edge.getEdgeTarget(); - if (canBeStronglyMatched(targetNode)) { - if (targetNode.isNullLiteral() || QVTscheduleUtil.getReferredProperty(navigationEdge).isIsRequired()) { - if (stronglyMatchedNodes.add(targetNode)) { - moreMoreNodes.add(targetNode); - } - } - } - } - else { - // SharedEdge - } - } - } - if (moreMoreNodes.size() <= 0) { - break; - } - moreStronglyMatchedNodes = moreMoreNodes; - } - this.stronglyMatchedNodes = new ArrayList<>(stronglyMatchedNodes); - Collections.sort(this.stronglyMatchedNodes, NameUtil.NAMEABLE_COMPARATOR); - return stronglyMatchedNodes; - } - - private Set<@NonNull Node> computeTraceNodes(@NonNull Iterable<@NonNull Node> headNodes) { - Set<@NonNull Node> traceNodes = new HashSet<>(); - for (@NonNull Node node : QVTscheduleUtil.getOwnedNodes(region)) { - if (node.basicGetUtility() == Utility.TRACE) { - traceNodes.add(node); - } - } - if (traceNodes.isEmpty()) { // A QVTc / legacy usage - deduce trace node(s) - for (@NonNull Node node : QVTscheduleUtil.getOwnedNodes(region)) { - if (node.isRealized() && scheduleManager.isMiddle(node)) { - traceNodes.add(node); - } - } - } - return traceNodes; - } - - private @NonNull Set<@NonNull Node> computeUnconditionalNodes(@NonNull Iterable<@NonNull Node> headNodes) { - @NonNull Set<@NonNull Node> unconditionalNodes = Sets.newHashSet(headNodes); - // Iterables.addAll(unconditionalNodes, region.getNewNodes()); - for (@NonNull Node node : QVTscheduleUtil.getOwnedNodes(region)) { - if (node.isNew() || node.isConstant()) { - unconditionalNodes.add(node); - } - } - for (@NonNull Edge edge : QVTscheduleUtil.getOwnedEdges(region)) { - if (edge.isRealized() && edge.isNavigation() && !edge.isSecondary()) { - Node sourceNode = edge.getEdgeSource(); - assert canBeUnconditional(sourceNode); - unconditionalNodes.add(sourceNode); - Node targetNode = edge.getEdgeTarget(); - assert canBeUnconditional(targetNode); - unconditionalNodes.add(targetNode); - } - } - Set<@NonNull Node> moreUnconditionalNodes = new HashSet<>(unconditionalNodes); - while (moreUnconditionalNodes.size() > 0) { - Set<@NonNull Node> moreMoreNodes = new HashSet<>(); - for (@NonNull Node node : moreUnconditionalNodes) { - for (@NonNull Edge incomingEdge : QVTscheduleUtil.getIncomingEdges(node)) { - assert !incomingEdge.isCast(); - Node sourceNode = incomingEdge.getEdgeSource(); - if (!canBeUnconditional(sourceNode)) {} - else if (incomingEdge.isComputation()) { - if (!isConditionalEdge(incomingEdge)) { - if (unconditionalNodes.add(sourceNode)) { - moreMoreNodes.add(sourceNode); - } - } - // if is <<then>> - // gather <<then>> visibilities - // gather <<else>> visibilities - // intersection <<then>>/<<else>> is unconditional - } - else if (incomingEdge.isNavigation()) { // Unconditional target has unconditional source - if (unconditionalNodes.add(sourceNode)) { - moreMoreNodes.add(sourceNode); - } - } - else { - System.out.println("Unsupported incoming edge in " + this + " : " + incomingEdge); - } - } - for (@NonNull Edge outgoingEdge : QVTscheduleUtil.getOutgoingEdges(node)) { - assert !outgoingEdge.isCast(); - Node targetNode = outgoingEdge.getEdgeTarget(); - if (!canBeUnconditional(targetNode)) {} - else if (outgoingEdge.isComputation()) {} - else if (outgoingEdge.isDependency()) {} - else if (outgoingEdge.isNavigation()) { - if (targetNode.isNullLiteral()) { - if (unconditionalNodes.add(targetNode)) { - moreMoreNodes.add(targetNode); - } - } - else if (node.isRequired() && QVTscheduleUtil.getReferredProperty((NavigationEdge)outgoingEdge).isIsRequired()) { - if (unconditionalNodes.add(targetNode)) { - moreMoreNodes.add(targetNode); - } - } - } - else { // SharedEdge - System.out.println("Unsupported outgoing edge in " + this + " : " + outgoingEdge); - } - } - } - if (moreMoreNodes.size() <= 0) { - break; - } - moreUnconditionalNodes = moreMoreNodes; - } - this.unconditionalNodes = new ArrayList<>(unconditionalNodes); - Collections.sort(this.unconditionalNodes, NameUtil.NAMEABLE_COMPARATOR); - return unconditionalNodes; - } - - private boolean isConditionalEdge(@NonNull Edge edge) { - if (edge instanceof OperationParameterEdge) { - OperationParameterEdge operationParameterEdge = (OperationParameterEdge)edge; - Parameter parameter = operationParameterEdge.getReferredParameter(); - if (parameter == qvtbaseLibraryHelper.getIfThenParameter()) { - return true; - } - else if (parameter == qvtbaseLibraryHelper.getIfElseParameter()) { - return true; - } - else if (parameter == qvtbaseLibraryHelper.getLoopBodyParameter()) { - return true; - } - } - return false; - } - - @Override - public String toString() { - return region.toString(); - } -}
\ No newline at end of file diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/trace/Element2MiddleProperty.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/trace/Element2MiddleProperty.java index 305b7ed9f..cc35053ec 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/trace/Element2MiddleProperty.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/trace/Element2MiddleProperty.java @@ -60,6 +60,9 @@ public abstract class Element2MiddleProperty implements Nameable this.nameHint = nameHint; this.type = type; this.isRequired = isRequired; + if ("welement2element".equals(nameHint)) { + getClass(); + } } protected abstract @NonNull Property createTraceProperty(); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/trace/TracedHeadAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/trace/TracedHeadAnalysis.java index 4af92f10a..f6bc07f82 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/trace/TracedHeadAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtb2qvts/trace/TracedHeadAnalysis.java @@ -101,7 +101,7 @@ public class TracedHeadAnalysis extends HeadAnalysis private @NonNull Map<@NonNull Node, @NonNull Set<@NonNull Node>> computeTracedTargetFromSources() { Map<@NonNull Node, @NonNull Set<@NonNull Node>> targetFromSources = new HashMap<>(); for (@NonNull Node targetNode : QVTscheduleUtil.getOwnedNodes(mappingRegion)) { - if (targetNode.isMatched() && !targetNode.isConstant()) { + if (!targetNode.isConditional() && !targetNode.isConstant()) { ClassDatum classDatum = QVTscheduleUtil.getClassDatum(targetNode); TypedModel typedModel = QVTscheduleUtil.getReferredTypedModel(classDatum); if (!typedModel.isIsTrace()) { // when/where invocation nodes are not part of the multi-sided trace @@ -112,7 +112,7 @@ public class TracedHeadAnalysis extends HeadAnalysis } for (@NonNull Edge edge : QVTscheduleUtil.getIncomingEdges(targetNode)) { Node sourceNode = edge.getEdgeSource(); - if (sourceNode.isMatched() && !sourceNode.isConstant()) { + if (!sourceNode.isConditional() && !sourceNode.isConstant()) { if (edge instanceof NavigationEdge) { if (!((NavigationEdge)edge).isPartial()) { sources.add(sourceNode); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtm2qvts/MappingAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtm2qvts/MappingAnalysis.java index 42666f1f2..e756fbc4e 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtm2qvts/MappingAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtm2qvts/MappingAnalysis.java @@ -33,7 +33,6 @@ import org.eclipse.ocl.pivot.VariableExp; import org.eclipse.ocl.pivot.ids.OperationId; import org.eclipse.ocl.pivot.utilities.ClassUtil; import org.eclipse.ocl.pivot.utilities.PivotUtil; -import org.eclipse.qvtd.compiler.internal.qvtb2qvts.UtilityAnalysis; import org.eclipse.qvtd.compiler.internal.utilities.CompilerUtil; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.ExpressionSynthesizer; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.RuleAnalysis; @@ -43,8 +42,11 @@ import org.eclipse.qvtd.pivot.qvtbase.Predicate; import org.eclipse.qvtd.pivot.qvtbase.utilities.QVTbaseUtil; import org.eclipse.qvtd.pivot.qvtcore.Assignment; import org.eclipse.qvtd.pivot.qvtcore.BottomPattern; +import org.eclipse.qvtd.pivot.qvtcore.BottomVariable; import org.eclipse.qvtd.pivot.qvtcore.CoreDomain; +import org.eclipse.qvtd.pivot.qvtcore.CoreModel; import org.eclipse.qvtd.pivot.qvtcore.CorePattern; +import org.eclipse.qvtd.pivot.qvtcore.EnforcementOperation; import org.eclipse.qvtd.pivot.qvtcore.GuardPattern; import org.eclipse.qvtd.pivot.qvtcore.Mapping; import org.eclipse.qvtd.pivot.qvtcore.NavigationAssignment; @@ -61,6 +63,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge; import org.eclipse.qvtd.pivot.qvtschedule.NavigationEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.utilities.DomainUsage; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; import com.google.common.collect.Iterables; @@ -70,97 +73,104 @@ import com.google.common.collect.Iterables; */ public class MappingAnalysis extends RuleAnalysis { - public static abstract class AbstractQVTcoreExpressionSynthesizer extends ExpressionSynthesizer implements QVTcoreVisitor<@Nullable Node> + public static abstract class AbstractQVTcoreExpressionSynthesizer + extends ExpressionSynthesizer + implements QVTcoreVisitor<@Nullable Node> { - protected AbstractQVTcoreExpressionSynthesizer(@NonNull RuleAnalysis context, @Nullable AbstractQVTcoreExpressionSynthesizer unconditionalExpressionSynthesizer) { - super(context, unconditionalExpressionSynthesizer); + protected AbstractQVTcoreExpressionSynthesizer(@NonNull RuleAnalysis context, + @Nullable AbstractQVTcoreExpressionSynthesizer unconditionalExpressionSynthesizer, + @NonNull InitUtility initUtility) { + super(context, unconditionalExpressionSynthesizer, initUtility); } @Override - public @Nullable Node visitAssignment(org.eclipse.qvtd.pivot.qvtcore.@NonNull Assignment object) { + public @Nullable Node visitAssignment(@NonNull Assignment object) { return visitElement(object); } @Override - public @Nullable Node visitBottomPattern(org.eclipse.qvtd.pivot.qvtcore.@NonNull BottomPattern object) { + public @Nullable Node visitBottomPattern(@NonNull BottomPattern object) { return visitCorePattern(object); } @Override - public @Nullable Node visitBottomVariable(org.eclipse.qvtd.pivot.qvtcore.@NonNull BottomVariable object) { + public @Nullable Node visitBottomVariable(@NonNull BottomVariable object) { return visitVariable(object); } @Override - public @Nullable Node visitCoreDomain(org.eclipse.qvtd.pivot.qvtcore.@NonNull CoreDomain object) { + public @Nullable Node visitCoreDomain(@NonNull CoreDomain object) { return visitDomain(object); } @Override - public @Nullable Node visitCoreModel(org.eclipse.qvtd.pivot.qvtcore.@NonNull CoreModel object) { + public @Nullable Node visitCoreModel(@NonNull CoreModel object) { return visitBaseModel(object); } @Override - public @Nullable Node visitCorePattern(org.eclipse.qvtd.pivot.qvtcore.@NonNull CorePattern object) { + public @Nullable Node visitCorePattern(@NonNull CorePattern object) { return visitPattern(object); } @Override - public @Nullable Node visitEnforcementOperation(org.eclipse.qvtd.pivot.qvtcore.@NonNull EnforcementOperation object) { + public @Nullable Node visitEnforcementOperation(@NonNull EnforcementOperation object) { return visitElement(object); } @Override - public @Nullable Node visitGuardPattern(org.eclipse.qvtd.pivot.qvtcore.@NonNull GuardPattern object) { + public @Nullable Node visitGuardPattern(@NonNull GuardPattern object) { return visitCorePattern(object); } @Override - public @Nullable Node visitGuardVariable(org.eclipse.qvtd.pivot.qvtcore.@NonNull GuardVariable object) { + public @Nullable Node visitGuardVariable( + org.eclipse.qvtd.pivot.qvtcore.@NonNull GuardVariable object) { return visitVariable(object); } @Override - public @Nullable Node visitMapping(org.eclipse.qvtd.pivot.qvtcore.@NonNull Mapping object) { + public @Nullable Node visitMapping(@NonNull Mapping object) { return visitRule(object); } @Override - public @Nullable Node visitNavigationAssignment(org.eclipse.qvtd.pivot.qvtcore.@NonNull NavigationAssignment object) { + public @Nullable Node visitNavigationAssignment(@NonNull NavigationAssignment object) { return visitAssignment(object); } @Override - public @Nullable Node visitOppositePropertyAssignment(org.eclipse.qvtd.pivot.qvtcore.@NonNull OppositePropertyAssignment object) { + public @Nullable Node visitOppositePropertyAssignment(@NonNull OppositePropertyAssignment object) { return visitNavigationAssignment(object); } @Override - public @Nullable Node visitPropertyAssignment(org.eclipse.qvtd.pivot.qvtcore.@NonNull PropertyAssignment object) { + public @Nullable Node visitPropertyAssignment(@NonNull PropertyAssignment object) { return visitNavigationAssignment(object); } @Override - public @Nullable Node visitRealizedVariable(org.eclipse.qvtd.pivot.qvtcore.@NonNull RealizedVariable object) { + public @Nullable Node visitRealizedVariable(@NonNull RealizedVariable object) { return visitVariable(object); } @Override - public @Nullable Node visitVariableAssignment(org.eclipse.qvtd.pivot.qvtcore.@NonNull VariableAssignment object) { + public @Nullable Node visitVariableAssignment(@NonNull VariableAssignment object) { return visitAssignment(object); } } public static class QVTcoreExpressionSynthesizer extends AbstractQVTcoreExpressionSynthesizer { - protected QVTcoreExpressionSynthesizer(@NonNull RuleAnalysis context, @Nullable QVTcoreExpressionSynthesizer unconditionalExpressionSynthesizer) { - super(context, unconditionalExpressionSynthesizer); + protected QVTcoreExpressionSynthesizer(@NonNull RuleAnalysis context, + @Nullable QVTcoreExpressionSynthesizer unconditionalExpressionSynthesizer, + @NonNull InitUtility initUtility) { + super(context, unconditionalExpressionSynthesizer, initUtility); } @Override - protected @NonNull ExpressionSynthesizer createConditionalExpressionSynthesizer() { - return new QVTcoreExpressionSynthesizer(context, this); + protected @NonNull ExpressionSynthesizer createExpressionSynthesizer(@NonNull InitUtility initUtility) { + return new QVTcoreExpressionSynthesizer(context, this, initUtility); } @Override @@ -176,14 +186,19 @@ public class MappingAnalysis extends RuleAnalysis ClassDatum valueClassDatum = QVTscheduleUtil.getClassDatum(valueNode); Type propertyType = PivotUtil.getType(property); if (asNavigationAssignment.isIsPartial()) { - propertyType = PivotUtil.getElementType(((CollectionType)propertyType)); + propertyType = PivotUtil.getElementType(((CollectionType) propertyType)); } CompleteClass targetCompleteClass = environmentFactory.getCompleteModel().getCompleteClass(propertyType); - // Type targetType = propertyType;//environmentFactory.getCompleteModel().getCompleteClass(propertyType); - if (!QVTscheduleUtil.conformsToClassOrBehavioralClass(valueClassDatum, targetCompleteClass)) { // Allow value to be physical or behavioral - if (!QVTscheduleUtil.conformsToClassOrBehavioralClass(valueClassDatum, targetCompleteClass)) { // Allow value to be physical or behavioral + // Type targetType = + // propertyType;//environmentFactory.getCompleteModel().getCompleteClass(propertyType); + if (!QVTscheduleUtil.conformsToClassOrBehavioralClass(valueClassDatum, targetCompleteClass)) { // Allow value to be physical or behavioral + if (!QVTscheduleUtil.conformsToClassOrBehavioralClass(valueClassDatum, targetCompleteClass)) { // Allow value to be physical or behavioral // FIXME we could synthesize a cast, but it's easier to do oclAsType() in QVTm - // if (!valueCompleteClass.conformsTo(targetCompleteClass.getBehavioralClass()) && !valueCompleteClass.conformsTo(targetCompleteClass.getBehavioralClass())) { + // if + // (!valueCompleteClass.conformsTo(targetCompleteClass.getBehavioralClass()) + // && + // !valueCompleteClass.conformsTo(targetCompleteClass.getBehavioralClass())) + // { // No test code follows this path. throw new IllegalStateException("Incompatible types " + valueClassDatum + ", " + targetCompleteClass + " for " + asNavigationAssignment); } @@ -208,8 +223,8 @@ public class MappingAnalysis extends RuleAnalysis } /** - * Predicates that are too complex to analyze. i.e. more than a comparison of a bound variable wrt - * a property call chain on another bound variable. + * Predicates that are too complex to analyze. i.e. more than a comparison + * of a bound variable wrt a property call chain on another bound variable. */ private final @NonNull Set<@NonNull Predicate> complexPredicates = new HashSet<>(); @@ -229,26 +244,28 @@ public class MappingAnalysis extends RuleAnalysis private final @NonNull List<@NonNull NavigationAssignment> navigationAssignments = new ArrayList<>(); /** - * The variable initializers, simple predicate reference expression and variable assignment values that define a value for each variable. - * Variable initializers are populated lazily since not all LetVariables may even exist for an eager population. + * The variable initializers, simple predicate reference expression and + * variable assignment values that define a value for each variable. + * Variable initializers are populated lazily since not all LetVariables may + * even exist for an eager population. */ private @NonNull Map<@NonNull VariableDeclaration, @NonNull List<@NonNull OCLExpression>> variable2expressions = new HashMap<>(); public MappingAnalysis(@NonNull AbstractTransformationAnalysis transformationAnalysis, @NonNull RuleRegion ruleRegion) { super(transformationAnalysis, ruleRegion); // - Mapping mapping = (Mapping)QVTscheduleUtil.getReferredRule(ruleRegion); + Mapping mapping = (Mapping) QVTscheduleUtil.getReferredRule(ruleRegion); GuardPattern guardPattern = QVTcoreUtil.getGuardPattern(mapping); BottomPattern bottomPattern = QVTcoreUtil.getBottomPattern(mapping); guardPatterns.add(guardPattern); bottomPatterns.add(bottomPattern); for (@NonNull Assignment assignment : QVTcoreUtil.getOwnedAssignments(bottomPattern)) { if (assignment instanceof NavigationAssignment) { - navigationAssignments.add((NavigationAssignment)assignment); - } - else if (assignment instanceof VariableAssignment) { - VariableAssignment variableAssignment = (VariableAssignment)assignment; - addExpression(QVTcoreUtil.getTargetVariable(variableAssignment), QVTcoreUtil.getValue(variableAssignment)); + navigationAssignments.add((NavigationAssignment) assignment); + } else if (assignment instanceof VariableAssignment) { + VariableAssignment variableAssignment = (VariableAssignment) assignment; + addExpression(QVTcoreUtil.getTargetVariable(variableAssignment), + QVTcoreUtil.getValue(variableAssignment)); } } for (@NonNull CoreDomain coreDomain : QVTcoreUtil.getOwnedDomains(mapping)) { @@ -258,10 +275,9 @@ public class MappingAnalysis extends RuleAnalysis bottomPatterns.add(bottomPattern); for (@NonNull Assignment assignment : QVTcoreUtil.getOwnedAssignments(bottomPattern)) { if (assignment instanceof NavigationAssignment) { - navigationAssignments.add((NavigationAssignment)assignment); - } - else if (assignment instanceof VariableAssignment) { - VariableAssignment variableAssignment = (VariableAssignment)assignment; + navigationAssignments.add((NavigationAssignment) assignment); + } else if (assignment instanceof VariableAssignment) { + VariableAssignment variableAssignment = (VariableAssignment) assignment; addExpression(QVTcoreUtil.getTargetVariable(variableAssignment), QVTcoreUtil.getValue(variableAssignment)); } } @@ -274,7 +290,7 @@ public class MappingAnalysis extends RuleAnalysis initializers = new ArrayList<>(); variable2expressions.put(variable, initializers); } - if (!initializers.contains(expression)) { // Shouldn't really happen but variable.ownedIInit is lazy + if (!initializers.contains(expression)) { // Shouldn't really happen but variable.ownedIInit is lazy initializers.add(expression); } } @@ -288,7 +304,7 @@ public class MappingAnalysis extends RuleAnalysis assignmentSorter.addAll(ClassUtil.nullFree(bottomPattern.getAssignment())); } for (@NonNull Assignment assignment : assignmentSorter.getSortedAssignments()) { - assignment.accept(unconditionalExpressionSynthesizer.getExpressionSynthesizer(assignment.isIsRequired())); + assignment.accept(rootExpressionSynthesizer.getRequiredExpressionSynthesizer(assignment.isIsRequired())); } } @@ -298,39 +314,36 @@ public class MappingAnalysis extends RuleAnalysis */ for (Predicate predicate : complexPredicates) { OCLExpression conditionExpression = predicate.getConditionExpression(); - /* if (conditionExpression instanceof OperationCallExp) { - OperationCallExp callExp = (OperationCallExp)conditionExpression; - OperationId operationId = callExp.getReferredOperation().getOperationId(); - if (ScheduleModel.isSameOperation(operationId, getScheduleModel().getOclAnyEqualsId())) { - OCLExpression leftExpression = callExp.getOwnedSource(); - OCLExpression rightExpression = callExp.getOwnedArguments().get(0); - Node leftNode = expressionAnalyzer.analyze(leftExpression); - Node rightNode = expressionAnalyzer.analyze(rightExpression); - if (leftNode != rightNode) { - if (leftNode.isKnown() && !(leftExpression instanceof NavigationCallExp)) { - QVTscheduleUtil.ARGUMENT.createEdge(this, leftNode, "=", rightNode); - } - else if (rightNode.isKnown() && !(rightExpression instanceof NavigationCallExp)) { - QVTscheduleUtil.ARGUMENT.createEdge(this, rightNode, "=", leftNode); - } - else if (leftNode.isKnown()) { - QVTscheduleUtil.ARGUMENT.createEdge(this, leftNode, "=", rightNode); - } - else if (rightNode.isKnown()) { - QVTscheduleUtil.ARGUMENT.createEdge(this, rightNode, "=", leftNode); - } - else { - QVTscheduleUtil.BINDING.createEdge(this, leftNode, null, rightNode); // FIXME - QVTscheduleUtil.BINDING.createEdge(this, rightNode, null, leftNode); - } - } - } - } - else { */ - Node resultNode = conditionExpression.accept(unconditionalExpressionSynthesizer); - if (resultNode != null) { - Node trueNode = createBooleanLiteralNode(true); - createPredicateEdge(resultNode, null, trueNode); + /* + * if (conditionExpression instanceof OperationCallExp) { + * OperationCallExp callExp = (OperationCallExp)conditionExpression; + * OperationId operationId = + * callExp.getReferredOperation().getOperationId(); if + * (ScheduleModel.isSameOperation(operationId, + * getScheduleModel().getOclAnyEqualsId())) { OCLExpression + * leftExpression = callExp.getOwnedSource(); OCLExpression + * rightExpression = callExp.getOwnedArguments().get(0); Node + * leftNode = expressionAnalyzer.analyze(leftExpression); Node + * rightNode = expressionAnalyzer.analyze(rightExpression); if + * (leftNode != rightNode) { if (leftNode.isKnown() && + * !(leftExpression instanceof NavigationCallExp)) { + * QVTscheduleUtil.ARGUMENT.createEdge(this, leftNode, "=", + * rightNode); } else if (rightNode.isKnown() && !(rightExpression + * instanceof NavigationCallExp)) { + * QVTscheduleUtil.ARGUMENT.createEdge(this, rightNode, "=", + * leftNode); } else if (leftNode.isKnown()) { + * QVTscheduleUtil.ARGUMENT.createEdge(this, leftNode, "=", + * rightNode); } else if (rightNode.isKnown()) { + * QVTscheduleUtil.ARGUMENT.createEdge(this, rightNode, "=", + * leftNode); } else { QVTscheduleUtil.BINDING.createEdge(this, + * leftNode, null, rightNode); // FIXME + * QVTscheduleUtil.BINDING.createEdge(this, rightNode, null, + * leftNode); } } } } else { + */ + Node resultNode = conditionExpression.accept(rootExpressionSynthesizer); + if (resultNode != null) { + Node trueNode = createBooleanLiteralNode(InitUtility.NON_NULL_MATCHED, true); + createPredicateEdge(InitUtility.NON_NULL_MATCHED, resultNode, null, trueNode); } // FIXME ?? do includes() here explicitly } @@ -342,7 +355,7 @@ public class MappingAnalysis extends RuleAnalysis boolean isContained = false; for (@NonNull Edge edge : QVTscheduleUtil.getOutgoingEdges(node)) { if (edge.isNavigation()) { - NavigationEdge navigationEdge = (NavigationEdge)edge; + NavigationEdge navigationEdge = (NavigationEdge) edge; Property property = QVTscheduleUtil.getReferredProperty(navigationEdge); Property opposite = property.getOpposite(); if ((opposite != null) && opposite.isIsComposite() && !edge.getEdgeTarget().isNullLiteral()) { @@ -366,21 +379,24 @@ public class MappingAnalysis extends RuleAnalysis for (@NonNull VariableDeclaration guardVariable : ClassUtil.nullFree(guardPattern.getOwnedVariables())) { Node guardNode = region.getNode(guardVariable); assert guardNode == null; - guardNode = createOldNode(guardVariable); + guardNode = createOldNode(InitUtility.NON_NULL_MATCHED, guardVariable); assert guardNode == region.getNode(guardVariable); } } } /** - * Analyze the predicates to partition the guard variables into the distinct inputs that are not mutually - * navigable as a consequence of predicate constraints. + * Analyze the predicates to partition the guard variables into the distinct + * inputs that are not mutually navigable as a consequence of predicate + * constraints. + * * @param bottomPatterns */ protected void analyzePredicates(@NonNull List<@NonNull ? extends CorePattern> corePatterns) { // - // Populate the targetVariable2sourceVariable2paths from the simple "a.b = c" style predicates, - // and cache those that are too hard to analyze as complex predicates. + // Populate the targetVariable2sourceVariable2paths from the simple "a.b + // = c" style predicates, + // and cache those that are too hard to analyze as complex predicates. // for (@NonNull CorePattern corePattern : corePatterns) { for (@NonNull Predicate predicate : ClassUtil.nullFree(corePattern.getPredicate())) { @@ -390,24 +406,22 @@ public class MappingAnalysis extends RuleAnalysis if (boundExpression instanceof VariableExp) { OCLExpression referenceExpression = getPredicateComparisonReferenceExpression(conditionExpression); assert referenceExpression != null; - VariableDeclaration referredVariable = QVTcoreUtil.getReferredVariable(((VariableExp)boundExpression)); - // if (referredVariable instanceof BottomVariable) { - // addExpression(referredVariable, referenceExpression); - // } - // else { + VariableDeclaration referredVariable = QVTcoreUtil.getReferredVariable(((VariableExp) boundExpression)); + // if (referredVariable instanceof BottomVariable) { + // addExpression(referredVariable, referenceExpression); + // } + // else { if (!analyzeSimplePredicate(referredVariable, referenceExpression)) { complexPredicates.add(predicate); } - // } - } - else if (boundExpression instanceof NullLiteralExp) { + // } + } else if (boundExpression instanceof NullLiteralExp) { OCLExpression referenceExpression = getPredicateComparisonReferenceExpression(conditionExpression); assert referenceExpression != null; if (!analyzeSimplePredicate(null, referenceExpression)) { complexPredicates.add(predicate); } - } - else { + } else { complexPredicates.add(predicate); } } @@ -424,7 +438,9 @@ public class MappingAnalysis extends RuleAnalysis for (@NonNull RealizedVariable realizedVariable : ClassUtil.nullFree(bottomPattern.getRealizedVariable())) { Node realizedNode = region.getNode(realizedVariable); assert realizedNode == null; - realizedNode = createRealizedStepNode(realizedVariable); + ClassDatum classDatum = scheduleManager.getClassDatum(realizedVariable); + boolean isTrace = classDatum.getReferredTypedModel().isIsTrace(); + realizedNode = createRealizedStepNode(isTrace ? InitUtility.TRACE : InitUtility.NON_NULL_MATCHED, realizedVariable); assert realizedNode == region.getNode(realizedVariable); } } @@ -432,6 +448,10 @@ public class MappingAnalysis extends RuleAnalysis @Override public void analyzeMappingRegion() { + String name = region.getName(); + if ("associationToForeignKey".equals(name)) { + getClass(); + } // // Create the BLUE/CYAN guard nodes. // @@ -439,7 +459,7 @@ public class MappingAnalysis extends RuleAnalysis // // Create the GREEN realized nodes. // - analyzeRealizedVariables(); // FIXME bottom variables too + analyzeRealizedVariables(); // FIXME bottom variables too // // Create the predicate/computation nodes and edges // @@ -452,20 +472,21 @@ public class MappingAnalysis extends RuleAnalysis // Iterable<@NonNull Node> headNodes = RuleHeadAnalysis.computeRuleHeadNodes(scheduleManager, region, null); Iterables.addAll(QVTscheduleUtil.Internal.getHeadNodesList(region), headNodes); - UtilityAnalysis.assignUtilities(scheduleManager, region); } // - // Install the targetVariable2sourceVariable2paths entries for a "boundVariable = referenceExpression" predicate, - // where the referenceExpression involves zero or more PropertyCallExps of a VariableExp. boundVariable may be null - // for a negative application condition. + // Install the targetVariable2sourceVariable2paths entries for a + // "boundVariable = referenceExpression" predicate, + // where the referenceExpression involves zero or more PropertyCallExps of a + // VariableExp. boundVariable may be null + // for a negative application condition. // - // A reverse entry is also created if no PropertyCallExp is not to-one. + // A reverse entry is also created if no PropertyCallExp is not to-one. // private boolean analyzeSimplePredicate(@Nullable VariableDeclaration boundVariable, @NonNull OCLExpression referenceExpression) { boolean isValid = false; - for (@NonNull OCLExpression expression = referenceExpression; expression instanceof NavigationCallExp; ) { - NavigationCallExp navigationCallExp = (NavigationCallExp)expression; + for (@NonNull OCLExpression expression = referenceExpression; expression instanceof NavigationCallExp;) { + NavigationCallExp navigationCallExp = (NavigationCallExp) expression; expression = ClassUtil.nonNullState(navigationCallExp.getOwnedSource()); if (expression instanceof VariableExp) { isValid = true; @@ -475,27 +496,26 @@ public class MappingAnalysis extends RuleAnalysis if (!isValid) { return false; } - for (@NonNull OCLExpression expression = referenceExpression; expression instanceof NavigationCallExp; ) { - NavigationCallExp navigationCallExp = (NavigationCallExp)expression; + for (@NonNull OCLExpression expression = referenceExpression; expression instanceof NavigationCallExp;) { + NavigationCallExp navigationCallExp = (NavigationCallExp) expression; Property referredProperty = PivotUtil.getReferredProperty(navigationCallExp); assert referredProperty != null; expression = ClassUtil.nonNullState(navigationCallExp.getOwnedSource()); if (expression instanceof VariableExp) { - VariableDeclaration sourceVariable = ((VariableExp)expression).getReferredVariable(); + VariableDeclaration sourceVariable = ((VariableExp) expression).getReferredVariable(); assert sourceVariable != null; - // assert guardVariables.contains(targetVariable); - // assert guardVariables.contains(sourceVariable); + // assert guardVariables.contains(targetVariable); + // assert guardVariables.contains(sourceVariable); Node sourceNode = getReferenceNode(sourceVariable); - Node targetNode = boundVariable != null ? getReferenceNode(boundVariable) : createNullLiteralNode(true, null); - // assert sourceNode.isGuard(); - // assert (boundVariable == null) || targetNode.isGuard(); + Node targetNode = boundVariable != null ? getReferenceNode(boundVariable) : createNullLiteralNode(InitUtility.NON_NULL_MATCHED, null); + // assert sourceNode.isGuard(); + // assert (boundVariable == null) || targetNode.isGuard(); assert sourceNode.isClass(); if (!referredProperty.isIsMany()) { Edge predicateEdge = sourceNode.getOutgoingPredicateEdge(referredProperty); if (predicateEdge == null) { - createNavigationEdge(sourceNode, referredProperty, targetNode, false); - } - else { + createNavigationEdge(InitUtility.NON_NULL_MATCHED, sourceNode, referredProperty, targetNode, false); + } else { assert predicateEdge.getEdgeTarget() == targetNode; } } @@ -506,15 +526,18 @@ public class MappingAnalysis extends RuleAnalysis private @Nullable Node analyzeVariable(@NonNull Variable variable, @NonNull List<@NonNull OCLExpression> expressions) { // - // Use something hard to compute as the initializer that creates an initNode in the hope that other - // initializers might be easier and optimized as simple navigation edges. + // Use something hard to compute as the initializer that creates an + // initNode in the hope that other + // initializers might be easier and optimized as simple navigation + // edges. // OCLExpression bestInitExpression = null; for (@NonNull OCLExpression initExpression : expressions) { - if (initExpression instanceof OperationCallExp ) { - OperationCallExp operationCallExp = (OperationCallExp)initExpression; + if (initExpression instanceof OperationCallExp) { + OperationCallExp operationCallExp = (OperationCallExp) initExpression; OperationId operationId = operationCallExp.getReferredOperation().getOperationId(); - if (!PivotUtil.isSameOperation(operationId, OperationId.OCLANY_EQUALS) && !PivotUtil.isSameOperation(operationId, OperationId.OCLANY_NOT_EQUALS)) { + if (!PivotUtil.isSameOperation(operationId, + OperationId.OCLANY_EQUALS) && !PivotUtil.isSameOperation(operationId, OperationId.OCLANY_NOT_EQUALS)) { bestInitExpression = initExpression; break; } @@ -526,62 +549,65 @@ public class MappingAnalysis extends RuleAnalysis if (bestInitExpression == null) { return null; } - Node bestInitNode = bestInitExpression.accept(unconditionalExpressionSynthesizer.getExpressionSynthesizer(variable.isIsRequired())); + Node bestInitNode = bestInitExpression.accept(rootExpressionSynthesizer.getRequiredExpressionSynthesizer(variable.isIsRequired())); assert bestInitNode != null; - /* if ((ownedInit instanceof OperationCallExp) && initNode.isOperation()) { - if (QVTbaseUtil.isIdentification(((OperationCallExp)ownedInit).getReferredOperation())) { - Node stepNode = QVTscheduleUtil.createRealizedStepNode(mappingRegion, variable); - QVTscheduleUtil.createEqualsEdge(initNode, stepNode); - initNode = stepNode; - } - // else if (variable.getType() instanceof CollectionType) { - // Node stepNode = QVTscheduleUtil.ATTRIBUTE.createNode(this, variable, (OperationCallExp)ownedInit); - // QVTscheduleUtil.RESULT.createEdge(this, initNode, null, stepNode); - // initNode = stepNode; - // } - else { - // Node stepNode = QVTscheduleUtil.STEP.createNode(this, variable.getName(), (OperationCallExp)ownedInit, initNode); - Node stepNode = QVTscheduleUtil.createLoadedStepNode(mappingRegion, variable); - QVTscheduleUtil.createEqualsEdge(initNode, stepNode); - initNode = stepNode; - } - } */ + /* + * if ((ownedInit instanceof OperationCallExp) && + * initNode.isOperation()) { if + * (QVTbaseUtil.isIdentification(((OperationCallExp)ownedInit). + * getReferredOperation())) { Node stepNode = + * QVTscheduleUtil.createRealizedStepNode(mappingRegion, variable); + * QVTscheduleUtil.createEqualsEdge(initNode, stepNode); initNode = + * stepNode; } // else if (variable.getType() instanceof CollectionType) + * { // Node stepNode = QVTscheduleUtil.ATTRIBUTE.createNode(this, + * variable, (OperationCallExp)ownedInit); // + * QVTscheduleUtil.RESULT.createEdge(this, initNode, null, stepNode); // + * initNode = stepNode; // } else { // Node stepNode = + * QVTscheduleUtil.STEP.createNode(this, variable.getName(), + * (OperationCallExp)ownedInit, initNode); Node stepNode = + * QVTscheduleUtil.createLoadedStepNode(mappingRegion, variable); + * QVTscheduleUtil.createEqualsEdge(initNode, stepNode); initNode = + * stepNode; } } + */ ClassDatum initClassDatum = QVTscheduleUtil.getClassDatum(bestInitNode); ClassDatum variableClassDatum = scheduleManager.getClassDatum(variable); if (!QVTscheduleUtil.conformsTo(initClassDatum, variableClassDatum)) { - Node castNode = createOldNode(variable); - unconditionalExpressionSynthesizer.createCastEdge(bestInitNode, variableClassDatum, castNode); + Node castNode = createOldNode(InitUtility.getRequiredInitUtility(variable), variable); + rootExpressionSynthesizer.createCastEdge(bestInitNode, variableClassDatum, castNode); bestInitNode = castNode; } - // if (Iterables.isEmpty(bestInitNode.getTypedElements())) { + // if (Iterables.isEmpty(bestInitNode.getTypedElements())) { bestInitNode.setOriginatingVariable(variable); - // } + // } region.addVariableNode(variable, bestInitNode); for (@NonNull OCLExpression initExpression : expressions) { if (initExpression != bestInitExpression) { - // FIXME if the extra init is a navigation we can add a navigation to the bestInitNode - Node initNode = bestInitExpression.accept(unconditionalExpressionSynthesizer); + // FIXME if the extra init is a navigation we can add a + // navigation to the bestInitNode + Node initNode = bestInitExpression.accept(rootExpressionSynthesizer); assert initNode != null; - createEqualsEdge(bestInitNode, initNode); + createEqualsEdge(initNode.getInitUtility(), bestInitNode, initNode); } } return bestInitNode; } /** - * Return the boundExpression if conditionExpression is of the form - * <br>"variable = referenceExpression" => VariableExp(variable) - * <br>"referenceExpression = variable" => VariableExp(variable) - * <br>"null = referenceExpression" => NullLiteralExp(null) - * <br>"referenceExpression = null" => NullLiteralExp(null) - * <br>"constant-expression = referenceExpression" => OCLExpression(constant) - * <br>"referenceExpression = constant-expression" => OCLExpression(constant) + * Return the boundExpression if conditionExpression is of the form <br> + * "variable = referenceExpression" => VariableExp(variable) <br> + * "referenceExpression = variable" => VariableExp(variable) <br> + * "null = referenceExpression" => NullLiteralExp(null) <br> + * "referenceExpression = null" => NullLiteralExp(null) <br> + * "constant-expression = referenceExpression" => OCLExpression(constant) + * <br> + * "referenceExpression = constant-expression" => OCLExpression(constant) * - * <br>Returns null otherwise. + * <br> + * Returns null otherwise. */ private @Nullable OCLExpression getPredicateComparisonBoundExpression(@NonNull OCLExpression conditionExpression) { if (conditionExpression instanceof OperationCallExp) { - OperationCallExp callExp = (OperationCallExp)conditionExpression; + OperationCallExp callExp = (OperationCallExp) conditionExpression; OperationId operationId = callExp.getReferredOperation().getOperationId(); if (PivotUtil.isSameOperation(operationId, scheduleManager.getStandardLibraryHelper().getOclAnyEqualsId())) { OCLExpression leftExp = callExp.getOwnedSource(); @@ -605,20 +631,20 @@ public class MappingAnalysis extends RuleAnalysis } /** - * Return the referenceExpression if conditionExpression is of the form "boundVariable = referenceExpression" or - * "referenceExpression = boundVariable". Returns null otherwise. + * Return the referenceExpression if conditionExpression is of the form + * "boundVariable = referenceExpression" or "referenceExpression = + * boundVariable". Returns null otherwise. */ private @Nullable OCLExpression getPredicateComparisonReferenceExpression(@NonNull OCLExpression conditionExpression) { if (conditionExpression instanceof OperationCallExp) { - OperationCallExp callExp = (OperationCallExp)conditionExpression; + OperationCallExp callExp = (OperationCallExp) conditionExpression; OperationId operationId = callExp.getReferredOperation().getOperationId(); if (PivotUtil.isSameOperation(operationId, scheduleManager.getStandardLibraryHelper().getOclAnyEqualsId())) { OCLExpression leftExp = callExp.getOwnedSource(); OCLExpression rightExp = callExp.getOwnedArguments().get(0); if (leftExp instanceof VariableExp) { return rightExp; - } - else if (rightExp instanceof VariableExp) { + } else if (rightExp instanceof VariableExp) { return leftExp; } IsConstantExpressionVisitor isConstantExpressionVisitor = new IsConstantExpressionVisitor(null); @@ -638,7 +664,7 @@ public class MappingAnalysis extends RuleAnalysis Node node = region.getNode(variableDeclaration); if (node == null) { if (variableDeclaration instanceof Variable) { - Variable variable = (Variable)variableDeclaration; + Variable variable = (Variable) variableDeclaration; OCLExpression ownedInit = variable.getOwnedInit(); if (ownedInit != null) { addExpression(variable, ownedInit); @@ -646,46 +672,47 @@ public class MappingAnalysis extends RuleAnalysis List<@NonNull OCLExpression> expressions = variable2expressions.get(variable); if (expressions != null) { node = analyzeVariable(variable, expressions); - } - else if (variable.eContainer() instanceof BottomPattern) { + } else if (variable.eContainer() instanceof BottomPattern) { DomainUsage domainUsage = scheduleManager.getDomainUsage(variable); - boolean isEnforceable = scheduleManager.isOutputInRule(QVTbaseUtil.getContainingRule(variable), variable) || domainUsage.isMiddle(); + boolean isEnforceable = scheduleManager.isOutputInRule(QVTbaseUtil.getContainingRule(variable), variable) + || domainUsage.isMiddle(); if (isEnforceable) { - // assert variable instanceof RealizedVariable; + // assert variable instanceof RealizedVariable; if (!(variable instanceof RealizedVariable)) { - CompilerUtil.addRegionError(getProblemHandler(), region, "Enforceable variable ''{0}'' has not been realized in ''{1}''", variable, region); + CompilerUtil.addRegionError(getProblemHandler(), region, + "Enforceable variable ''{0}'' has not been realized in ''{1}''", + variable, region); } - node = createRealizedStepNode(variable); - } - else { - node = createLoadedStepNode(variable); // FIXME Predicated ?? + node = createRealizedStepNode(InitUtility.getRequiredInitUtility(variable), variable); + } else { + node = createLoadedStepNode(InitUtility.getRequiredInitUtility(variable), variable); // FIXME Predicated ?? } } } } assert node != null : "No variable2simpleNode entry for " + variableDeclaration; return node; - /* if (variable instanceof RealizedVariable) { - return QVTscheduleUtil.REALIZED_VARIABLE.createNode(this, (RealizedVariable)variable); - } - else if (variable.eContainer() instanceof BottomPattern) { - return QVTscheduleUtil.UNREALIZED_VARIABLE.createNode(this, variable); - } - else { - return new GuardVariableNode(this, variable); - } */ + /* + * if (variable instanceof RealizedVariable) { return + * QVTscheduleUtil.REALIZED_VARIABLE.createNode(this, + * (RealizedVariable)variable); } else if (variable.eContainer() + * instanceof BottomPattern) { return + * QVTscheduleUtil.UNREALIZED_VARIABLE.createNode(this, variable); } + * else { return new GuardVariableNode(this, variable); } + */ } /** - * Return true if the navigation from sourceNode using source2targetProperty corresponds to a PropertyAssigmment, + * Return true if the navigation from sourceNode using source2targetProperty + * corresponds to a PropertyAssigmment, */ @Override public boolean isPropertyAssignment(@NonNull Node sourceNode, @NonNull Property source2targetProperty) { if (sourceNode.isRealized()) { for (@NonNull NavigationAssignment navigationAssignment : navigationAssignments) { Property navigationProperty = QVTcoreUtil.getTargetProperty(navigationAssignment); - if (source2targetProperty == navigationProperty) { // ??? opposites ??? do they even exist ??? - Node slotNode = unconditionalExpressionSynthesizer.synthesize(navigationAssignment.getSlotExpression()); + if (source2targetProperty == navigationProperty) { // ??? opposites ??? do they even exist ??? + Node slotNode = rootExpressionSynthesizer.synthesize(navigationAssignment.getSlotExpression()); if (slotNode == sourceNode) { return true; } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtm2qvts/QVTcoreScheduleManager.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtm2qvts/QVTcoreScheduleManager.java index 564d5d0a0..fc6bb0f55 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtm2qvts/QVTcoreScheduleManager.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtm2qvts/QVTcoreScheduleManager.java @@ -32,6 +32,7 @@ import org.eclipse.qvtd.pivot.qvtbase.TypedModel; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.QVTscheduleFactory; import org.eclipse.qvtd.pivot.qvtschedule.RuleRegion; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.RootRegion; public class QVTcoreScheduleManager extends BasicScheduleManager @@ -56,6 +57,11 @@ public class QVTcoreScheduleManager extends BasicScheduleManager } @Override + public @NonNull ExpressionSynthesizer createRootExpressionSynthesizer(@NonNull RuleAnalysis ruleAnalysis) { + return new QVTcoreExpressionSynthesizer(ruleAnalysis, null, InitUtility.NON_NULL_MATCHED); + } + + @Override public @NonNull MappingAnalysis createRuleAnalysis(@NonNull AbstractTransformationAnalysis transformationAnalysis, @NonNull Rule asRule) { RuleRegion ruleRegion = QVTscheduleFactory.eINSTANCE.createRuleRegion(); ruleRegion.setOwningScheduleModel(scheduleModel); @@ -90,11 +96,6 @@ public class QVTcoreScheduleManager extends BasicScheduleManager } @Override - public @NonNull ExpressionSynthesizer createUnconditionalExpressionSynthesizer(@NonNull RuleAnalysis ruleAnalysis) { - return new QVTcoreExpressionSynthesizer(ruleAnalysis, null); - } - - @Override public @NonNull AbstractTransformationAnalysis getTransformationAnalysis() { return transformationAnalysis; } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractInvocationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractInvocationAnalysis.java index 83d7b1795..74fbbc272 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractInvocationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractInvocationAnalysis.java @@ -28,6 +28,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.SuccessEdge; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * An InvocationAnalysis identifies the invocation of one Relation from another. @@ -39,20 +40,18 @@ public abstract class AbstractInvocationAnalysis implements InvocationAnalysis protected final @NonNull RelationAnalysis invokingRelationAnalysis; protected final @NonNull RelationAnalysis invokedRelationAnalysis; protected final @NonNull QVTrelationScheduleManager scheduleManager; - protected final @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode = new HashMap<>(); + protected final @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode; + protected final @NonNull InitUtility initUtility; private @Nullable Node invokingNode = null; private final @NonNull Map<@NonNull Node, @NonNull Boolean> argumentNode2isOutput = new HashMap<>(); - public AbstractInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis) { + public AbstractInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis, @NonNull InitUtility initUtility, + @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { this.invokingRelationAnalysis = invokingRelationAnalysis; this.invokedRelationAnalysis = invokedRelationAnalysis; this.scheduleManager = invokedRelationAnalysis.getScheduleManager(); - } - - @Override - public void addBinding(@NonNull VariableDeclaration rootVariable, @NonNull Node argumentNode) { - Node oldNode = rootVariable2argumentNode.put(rootVariable, argumentNode); - assert oldNode == null; + this.rootVariable2argumentNode = rootVariable2argumentNode; + this.initUtility = initUtility; } /** @@ -90,7 +89,7 @@ public abstract class AbstractInvocationAnalysis implements InvocationAnalysis Invocation2TraceProperty invokingInvocation2TraceProperty = invokingRule2TraceClass.getInvocation2TraceProperty(this); Property invocationTraceProperty = invokingInvocation2TraceProperty.getTraceProperty(); boolean isPartial = scheduleManager.computeIsPartial(invokedNode, invocationTraceProperty); - invokingRelationAnalysis.createRealizedNavigationEdge(invokingTraceNode, invocationTraceProperty, invokedNode, isPartial); + invokingRelationAnalysis.createRealizedNavigationEdge(initUtility, invokingTraceNode, invocationTraceProperty, invokedNode, isPartial); } /** @@ -163,10 +162,11 @@ public abstract class AbstractInvocationAnalysis implements InvocationAnalysis } /** - * Return true unless a derived analysis permits an optional match. + * Return false since all where and many when matches are optional. */ - protected boolean isMatched() { - return true; + @Override + public final boolean isOptional() { + return initUtility.isNullable(); } @Override @@ -180,6 +180,11 @@ public abstract class AbstractInvocationAnalysis implements InvocationAnalysis return invokingNode.isRealized(); } + // @Override + // public boolean isRequired() { + // return false; + // } + @Override public boolean needsInvocationTraceProperty() { return true; diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractQVTrelationExpressionSynthesizer.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractQVTrelationExpressionSynthesizer.java index 247b1e5c5..71d76fd6e 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractQVTrelationExpressionSynthesizer.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractQVTrelationExpressionSynthesizer.java @@ -15,11 +15,12 @@ import org.eclipse.jdt.annotation.Nullable; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.ExpressionSynthesizer; import org.eclipse.qvtd.pivot.qvtrelation.util.QVTrelationVisitor; import org.eclipse.qvtd.pivot.qvtschedule.Node; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; public abstract class AbstractQVTrelationExpressionSynthesizer extends ExpressionSynthesizer implements QVTrelationVisitor<@Nullable Node> { - protected AbstractQVTrelationExpressionSynthesizer(@NonNull RelationAnalysis context, @Nullable AbstractQVTrelationExpressionSynthesizer unconditionalExpressionSynthesizer) { - super(context, unconditionalExpressionSynthesizer); + protected AbstractQVTrelationExpressionSynthesizer(@NonNull RelationAnalysis context, @Nullable AbstractQVTrelationExpressionSynthesizer unconditionalExpressionSynthesizer, @NonNull InitUtility initUtility) { + super(context, unconditionalExpressionSynthesizer, initUtility); } @Override diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractWhenInvocationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractWhenInvocationAnalysis.java index 11410f24b..c04696112 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractWhenInvocationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/AbstractWhenInvocationAnalysis.java @@ -10,9 +10,12 @@ *******************************************************************************/ package org.eclipse.qvtd.compiler.internal.qvtr2qvts; +import java.util.Map; + import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.eclipse.ocl.pivot.Property; +import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.trace.Element2MiddleProperty; import org.eclipse.qvtd.compiler.internal.qvtr2qvts.trace.Relation2MiddleType; import org.eclipse.qvtd.pivot.qvtrelation.Relation; @@ -21,6 +24,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.SuccessEdge; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * An AbstractWhenInvocationAnalysis identifies the invocation of one Relation from the when clause of another. @@ -29,13 +33,14 @@ public abstract class AbstractWhenInvocationAnalysis extends AbstractInvocationA { private @Nullable SuccessEdge globalSuccessEdge = null; - public AbstractWhenInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis) { - super(invokingRelationAnalysis, invokedRelationAnalysis); + public AbstractWhenInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis, + @NonNull InitUtility initUtility, @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { + super(invokingRelationAnalysis, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } @Override protected @NonNull NavigableEdge createInputEdge(@NonNull Node invokedNode, @NonNull Property invocationProperty, @NonNull Node argumentNode) { - return invokingRelationAnalysis.createNavigationEdge(Role.PREDICATED, invokedNode, invocationProperty, argumentNode, false); + return invokingRelationAnalysis.createNavigationEdge(Role.PREDICATED, initUtility, invokedNode, invocationProperty, argumentNode, false); } @Override @@ -44,10 +49,11 @@ public abstract class AbstractWhenInvocationAnalysis extends AbstractInvocationA Relation invokedRelation = invokedRelationAnalysis.getRule(); String name = nameGenerator.createWhenInvocationPropertyName(invokedRelation); ClassDatum classDatum = getInvokedClassDatum(); - boolean isMatched = isMatched(); - return createInvocationNode(name, classDatum, isMatched); + return createInvocationNode(name, classDatum); } + protected abstract @NonNull Node createInvocationNode(@NonNull String name, @NonNull ClassDatum classDatum); + @Override protected void createInvokingTraceEdge(@NonNull Node invokedNode, @NonNull Node invokingTraceNode) { if (needsInvocationTraceProperty()) { @@ -57,7 +63,7 @@ public abstract class AbstractWhenInvocationAnalysis extends AbstractInvocationA @Override protected @NonNull NavigableEdge createOutputEdge(@NonNull Node invokedNode, @NonNull Property invocationProperty, @NonNull Node argumentNode) { - return invokingRelationAnalysis.createNavigationEdge(Role.PREDICATED, invokedNode, invocationProperty, argumentNode, false); + return invokingRelationAnalysis.createNavigationEdge(Role.PREDICATED, initUtility, invokedNode, invocationProperty, argumentNode, false); } @Override @@ -68,7 +74,7 @@ public abstract class AbstractWhenInvocationAnalysis extends AbstractInvocationA Relation2MiddleType invokedRelation2InvocationInterface = getInvokedRelation2InvocationInterface(); Element2MiddleProperty relation2globalSuccessProperty = invokedRelation2InvocationInterface.getRelation2GlobalSuccessProperty(); Property globalSuccessProperty = relation2globalSuccessProperty.getTraceProperty(); - globalSuccessEdge = globalSuccessEdge2 = invokingRelationAnalysis.createPredicatedSuccess(invokingNode, globalSuccessProperty, successStatus); + globalSuccessEdge = globalSuccessEdge2 = invokingRelationAnalysis.createPredicatedSuccess(initUtility, invokingNode, globalSuccessProperty, successStatus); } return globalSuccessEdge2; } @@ -79,14 +85,12 @@ public abstract class AbstractWhenInvocationAnalysis extends AbstractInvocationA } @Override - public @NonNull String toString() { - return invokingRelationAnalysis.getRule().getName() + "==when==top==>" + invokedRelationAnalysis.getRule().getName(); + public final boolean isWhen() { + return true; } - protected abstract @NonNull Node createInvocationNode(@NonNull String name, @NonNull ClassDatum classDatum, boolean isMatched); - @Override - public final boolean isWhen() { - return true; + public @NonNull String toString() { + return invokingRelationAnalysis.getRule().getName() + "==when==top==>" + invokedRelationAnalysis.getRule().getName(); } }
\ No newline at end of file diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/InvocationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/InvocationAnalysis.java index dc134ad66..ce457a157 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/InvocationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/InvocationAnalysis.java @@ -12,7 +12,6 @@ package org.eclipse.qvtd.compiler.internal.qvtr2qvts; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; -import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.SuccessEdge; @@ -21,14 +20,19 @@ import org.eclipse.qvtd.pivot.qvtschedule.SuccessEdge; */ public interface InvocationAnalysis { - void addBinding(@NonNull VariableDeclaration rootVariable, @NonNull Node argumentNode); @NonNull Iterable<@NonNull Node> getArgumentNodes(); @Nullable SuccessEdge getGlobalSuccessEdge(@Nullable Boolean successStatus); - @NonNull Node getInvokingNode(); @NonNull RelationAnalysis getInvokedRelationAnalysis(); + @NonNull Node getInvokingNode(); @NonNull RelationAnalysis getInvokingRelationAnalysis(); /** + * Return false unless a derived analysis permits an optional match. + * Return false if this invocation is guaranteed to occur. i.e. a not-optional when.. + */ + boolean isOptional(); + + /** * Return true if the argument node is to an output of the invoking rule, false if not, nullif not related to the invocation. */ @Nullable Boolean isOutput(@NonNull Node node); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhenAfterWhereInvocationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhenAfterWhereInvocationAnalysis.java index d0540fa57..41efd9940 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhenAfterWhereInvocationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhenAfterWhereInvocationAnalysis.java @@ -10,10 +10,14 @@ *******************************************************************************/ package org.eclipse.qvtd.compiler.internal.qvtr2qvts; +import java.util.Map; + import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.pivot.qvtrelation.Relation; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.Node; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * A NonTopWhenAfterWhereInvocationAnalysis identifies the invocation of a non-top Relation by a when clause in another. @@ -21,13 +25,14 @@ import org.eclipse.qvtd.pivot.qvtschedule.Node; */ public class NonTopWhenAfterWhereInvocationAnalysis extends AbstractWhenInvocationAnalysis { - public NonTopWhenAfterWhereInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis) { - super(invokingRelationAnalysis, invokedRelationAnalysis); + public NonTopWhenAfterWhereInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis, + @NonNull InitUtility initUtility, @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { + super(invokingRelationAnalysis, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } @Override - protected @NonNull Node createInvocationNode(@NonNull String name, @NonNull ClassDatum classDatum, boolean isMatched) { - return invokingRelationAnalysis.createPredicatedNode(name, classDatum, isMatched); + protected @NonNull Node createInvocationNode(@NonNull String name, @NonNull ClassDatum classDatum) { + return invokingRelationAnalysis.createPredicatedNode(initUtility, name, classDatum); } @Override diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhenOnlyInvocationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhenOnlyInvocationAnalysis.java index 7e19beff7..dd9aacf23 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhenOnlyInvocationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhenOnlyInvocationAnalysis.java @@ -10,12 +10,16 @@ *******************************************************************************/ package org.eclipse.qvtd.compiler.internal.qvtr2qvts; +import java.util.Map; + import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.Property; +import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.Role; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * A NonTopWhenOnlyInvocationAnalysis identifies the invocation of a non-top Relation by a when clause in another. @@ -23,18 +27,19 @@ import org.eclipse.qvtd.pivot.qvtschedule.Role; */ public class NonTopWhenOnlyInvocationAnalysis extends AbstractWhenInvocationAnalysis { - public NonTopWhenOnlyInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis) { - super(invokingRelationAnalysis, invokedRelationAnalysis); + public NonTopWhenOnlyInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis, + @NonNull InitUtility initUtility, @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { + super(invokingRelationAnalysis, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } @Override protected @NonNull NavigableEdge createInputEdge(@NonNull Node invokedNode, @NonNull Property invocationProperty, @NonNull Node argumentNode) { - return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, invokedNode, invocationProperty, argumentNode, false); + return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, initUtility, invokedNode, invocationProperty, argumentNode, false); } @Override - protected @NonNull Node createInvocationNode(@NonNull String name, @NonNull ClassDatum classDatum, boolean isMatched) { - return invokingRelationAnalysis.createRealizedNode(name, classDatum, isMatched); + protected @NonNull Node createInvocationNode(@NonNull String name, @NonNull ClassDatum classDatum) { + return invokingRelationAnalysis.createRealizedNode(initUtility, name, classDatum); } @Override diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhereBeforeWhenInvocationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhereBeforeWhenInvocationAnalysis.java index 21a260fb5..f3f7708f5 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhereBeforeWhenInvocationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhereBeforeWhenInvocationAnalysis.java @@ -10,13 +10,17 @@ *******************************************************************************/ package org.eclipse.qvtd.compiler.internal.qvtr2qvts; +import java.util.Map; + import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.Property; +import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.pivot.qvtrelation.Relation; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.Role; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * A NonTopWhereOnlyInvocationAnalysis identifies the invocation of a non-top Relation by a where clause in another. @@ -24,13 +28,14 @@ import org.eclipse.qvtd.pivot.qvtschedule.Role; */ public class NonTopWhereBeforeWhenInvocationAnalysis extends AbstractInvocationAnalysis { - public NonTopWhereBeforeWhenInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis) { - super(invokingRelationAnalysis, invokedRelationAnalysis); + public NonTopWhereBeforeWhenInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis, + @NonNull InitUtility initUtility, @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { + super(invokingRelationAnalysis, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } @Override protected @NonNull NavigableEdge createInputEdge(@NonNull Node invokedNode, @NonNull Property invocationProperty, @NonNull Node argumentNode) { - return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, invokedNode, invocationProperty, argumentNode, false); + return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, initUtility, invokedNode, invocationProperty, argumentNode, false); } @Override @@ -39,12 +44,12 @@ public class NonTopWhereBeforeWhenInvocationAnalysis extends AbstractInvocationA Relation invokedRelation = invokedRelationAnalysis.getRule(); String name = nameGenerator.createWhereInvocationPropertyName(invokedRelation); ClassDatum classDatum = getInvokedClassDatum(); - return invokingRelationAnalysis.createRealizedNode(name, classDatum, true); + return invokingRelationAnalysis.createRealizedNode(initUtility, name, classDatum); } @Override protected @NonNull NavigableEdge createOutputEdge(@NonNull Node invokedNode, @NonNull Property invocationProperty, @NonNull Node argumentNode) { - return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, invokedNode, invocationProperty, argumentNode, false); + return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, initUtility, invokedNode, invocationProperty, argumentNode, false); } /* @Override diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhereOnlyInvocationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhereOnlyInvocationAnalysis.java index a9e3fca47..28e5d2ddc 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhereOnlyInvocationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/NonTopWhereOnlyInvocationAnalysis.java @@ -10,13 +10,17 @@ *******************************************************************************/ package org.eclipse.qvtd.compiler.internal.qvtr2qvts; +import java.util.Map; + import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.Property; +import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.pivot.qvtrelation.Relation; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.Role; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * A NonTopWhereOnlyInvocationAnalysis identifies the invocation of a non-top Relation by a where clause in another. @@ -24,13 +28,14 @@ import org.eclipse.qvtd.pivot.qvtschedule.Role; */ public class NonTopWhereOnlyInvocationAnalysis extends AbstractInvocationAnalysis { - public NonTopWhereOnlyInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis) { - super(invokingRelationAnalysis, invokedRelationAnalysis); + public NonTopWhereOnlyInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis, + @NonNull InitUtility initUtility, @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { + super(invokingRelationAnalysis, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } @Override protected @NonNull NavigableEdge createInputEdge(@NonNull Node invokedNode, @NonNull Property invocationProperty, @NonNull Node argumentNode) { - return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, invokedNode, invocationProperty, argumentNode, false); + return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, initUtility, invokedNode, invocationProperty, argumentNode, false); } @Override @@ -39,12 +44,12 @@ public class NonTopWhereOnlyInvocationAnalysis extends AbstractInvocationAnalysi Relation invokedRelation = invokedRelationAnalysis.getRule(); String name = nameGenerator.createWhereInvocationPropertyName(invokedRelation); ClassDatum classDatum = getInvokedClassDatum(); - return invokingRelationAnalysis.createRealizedNode(name, classDatum, true); + return invokingRelationAnalysis.createRealizedNode(initUtility, name, classDatum); } @Override protected @NonNull NavigableEdge createOutputEdge(@NonNull Node invokedNode, @NonNull Property invocationProperty, @NonNull Node argumentNode) { - return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, invokedNode, invocationProperty, argumentNode, false); + return invokingRelationAnalysis.createNavigationEdge(Role.REALIZED, initUtility, invokedNode, invocationProperty, argumentNode, false); } /* @Override diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationDirectedScheduleManager.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationDirectedScheduleManager.java index 41dc59224..74996f9f4 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationDirectedScheduleManager.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationDirectedScheduleManager.java @@ -96,6 +96,11 @@ public class QVTrelationDirectedScheduleManager extends BasicScheduleManager imp } @Override + public @NonNull ExpressionSynthesizer createRootExpressionSynthesizer(@NonNull RuleAnalysis ruleAnalysis) { + return multipleScheduleManager.createRootExpressionSynthesizer(ruleAnalysis); + } + + @Override public @NonNull RelationAnalysis createRuleAnalysis(@NonNull AbstractTransformationAnalysis transformationAnalysis, @NonNull Rule asRule) { RuleRegion ruleRegion = QVTscheduleFactory.eINSTANCE.createRuleRegion(); ruleRegion.setOwningScheduleModel(scheduleModel); @@ -124,11 +129,6 @@ public class QVTrelationDirectedScheduleManager extends BasicScheduleManager imp throw new UnsupportedOperationException(); } - @Override - public @NonNull ExpressionSynthesizer createUnconditionalExpressionSynthesizer(@NonNull RuleAnalysis ruleAnalysis) { - return multipleScheduleManager.createUnconditionalExpressionSynthesizer(ruleAnalysis); - } - public @NonNull String getDirectedName(@NonNull Transformation asTransformation) { StringBuilder s = new StringBuilder(); s.append(QVTbaseUtil.getName(asTransformation)); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationExpressionSynthesizer.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationExpressionSynthesizer.java index b669687a5..02e6cef51 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationExpressionSynthesizer.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationExpressionSynthesizer.java @@ -10,7 +10,9 @@ *******************************************************************************/ package org.eclipse.qvtd.compiler.internal.qvtr2qvts; +import java.util.HashMap; import java.util.List; +import java.util.Map; import org.eclipse.emf.ecore.EObject; import org.eclipse.jdt.annotation.NonNull; @@ -26,18 +28,19 @@ import org.eclipse.qvtd.pivot.qvtrelation.RelationCallExp; import org.eclipse.qvtd.pivot.qvtrelation.utilities.QVTrelationUtil; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.SuccessEdge; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; import org.eclipse.qvtd.pivot.qvttemplate.TemplateExp; public class QVTrelationExpressionSynthesizer extends AbstractQVTrelationExpressionSynthesizer { - protected QVTrelationExpressionSynthesizer(@NonNull RelationAnalysis context, @Nullable QVTrelationExpressionSynthesizer unconditionalExpressionSynthesizer) { - super(context, unconditionalExpressionSynthesizer); + protected QVTrelationExpressionSynthesizer(@NonNull RelationAnalysis context, @Nullable QVTrelationExpressionSynthesizer unconditionalExpressionSynthesizer, @NonNull InitUtility initUtility) { + super(context, unconditionalExpressionSynthesizer, initUtility); } @Override - protected @NonNull ExpressionSynthesizer createConditionalExpressionSynthesizer() { - return new QVTrelationExpressionSynthesizer(getRelationAnalysis(), this); + protected @NonNull ExpressionSynthesizer createExpressionSynthesizer(@NonNull InitUtility initUtility) { + return new QVTrelationExpressionSynthesizer(getRelationAnalysis(), this, initUtility); } public @NonNull RelationAnalysis getRelationAnalysis() { @@ -63,7 +66,7 @@ public class QVTrelationExpressionSynthesizer extends AbstractQVTrelationExpress Relation invokedRelation = QVTrelationUtil.getReferredRelation(relationCallExp); RelationAnalysis invokedRelationAnalysis = (RelationAnalysis) context.getTransformationAnalysis().getRuleAnalysis(invokedRelation); // - InvocationAnalysis invocationAnalysis = relationAnalysis.getOutgoingInvocationAnalysis(invokedRelationAnalysis, relationCallExp, isWhen); + Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode = new HashMap<>(); List<@NonNull VariableDeclaration> rootVariables = QVTrelationUtil.getRootVariables(invokedRelation); List<@NonNull OCLExpression> ownedArguments = QVTrelationUtil.Internal.getOwnedArgumentsList(relationCallExp); int size = rootVariables.size(); @@ -73,15 +76,19 @@ public class QVTrelationExpressionSynthesizer extends AbstractQVTrelationExpress OCLExpression ownedArgument = ownedArguments.get(i); Node argumentNode = ownedArgument.accept(this); assert argumentNode != null; - invocationAnalysis.addBinding(rootVariable, argumentNode); + rootVariable2argumentNode.put(rootVariable, argumentNode); } + InvocationAnalysis invocationAnalysis = relationAnalysis.getOutgoingInvocationAnalysis(invokedRelationAnalysis, relationCallExp, isWhen, getRequiredInitUtility(true), rootVariable2argumentNode); // for () // if (referredRule2TraceClass.getStatusInterfaceProperty()) invocationAnalysis.getInvokingNode(); EObject eContainer = relationCallExp.eContainer(); boolean isDirectCall = eContainer instanceof Predicate; + // if (!isDirectCall) { + // getClass(); + // } SuccessEdge globalSuccessEdge = invocationAnalysis.getGlobalSuccessEdge(isDirectCall ? Boolean.TRUE : null); - return globalSuccessEdge != null ? QVTscheduleUtil.getTargetNode(globalSuccessEdge) : isDirectCall ? null : relationAnalysis.createBooleanLiteralNode(true); + return globalSuccessEdge != null ? QVTscheduleUtil.getTargetNode(globalSuccessEdge) : isDirectCall ? null : relationAnalysis.createBooleanLiteralNode(getNonNullUtility(), true); } @Override diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationMultipleScheduleManager.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationMultipleScheduleManager.java index d10d2a465..63555962a 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationMultipleScheduleManager.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/QVTrelationMultipleScheduleManager.java @@ -39,6 +39,7 @@ import org.eclipse.qvtd.pivot.qvtrelation.RelationalTransformation; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.RootRegion; import org.eclipse.qvtd.pivot.qvtschedule.ScheduleModel; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * A QVTrelationMultipleScheduleManager supervises and proviides the shared functionality for a distinct @@ -87,6 +88,11 @@ public class QVTrelationMultipleScheduleManager extends BasicScheduleManager imp } @Override + public @NonNull ExpressionSynthesizer createRootExpressionSynthesizer(@NonNull RuleAnalysis ruleAnalysis) { + return new QVTrelationExpressionSynthesizer((RelationAnalysis) ruleAnalysis, null, InitUtility.NON_NULL_MATCHED); + } + + @Override public @NonNull Rule2TraceGroup createRule2TraceGroup(@NonNull Transformation2TracePackage transformation2TracePackage, @NonNull Rule rule) { return new Relation2TraceGroup(transformation2TracePackage, (Relation)rule); } @@ -106,11 +112,6 @@ public class QVTrelationMultipleScheduleManager extends BasicScheduleManager imp return new RelationalTransformation2TracePackage(this, (RelationalTransformation)transformation); } - @Override - public @NonNull ExpressionSynthesizer createUnconditionalExpressionSynthesizer(@NonNull RuleAnalysis ruleAnalysis) { - return new QVTrelationExpressionSynthesizer((RelationAnalysis) ruleAnalysis, null); - } - protected @NonNull DatumCaches getDatumCaches() { return datumCaches; } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationAnalysis.java index 14e3c8251..983ad183e 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationAnalysis.java @@ -35,7 +35,6 @@ import org.eclipse.ocl.pivot.ids.OperationId; import org.eclipse.ocl.pivot.utilities.ClassUtil; import org.eclipse.ocl.pivot.utilities.PivotUtil; import org.eclipse.ocl.pivot.utilities.TreeIterable; -import org.eclipse.qvtd.compiler.internal.qvtb2qvts.UtilityAnalysis; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.trace.Element2MiddleProperty; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.ExpressionSynthesizer; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.RuleAnalysis; @@ -70,7 +69,6 @@ import org.eclipse.qvtd.pivot.qvtrelation.TemplateVariable; import org.eclipse.qvtd.pivot.qvtrelation.utilities.QVTrelationUtil; import org.eclipse.qvtd.pivot.qvtschedule.RuleRegion; import org.eclipse.qvtd.pivot.qvtschedule.VerdictRegion; -import org.eclipse.qvtd.pivot.qvtschedule.Node.Utility; import org.eclipse.qvtd.pivot.qvtschedule.BooleanLiteralNode; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.DispatchRegion; @@ -81,6 +79,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.NavigationEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.PropertyDatum; import org.eclipse.qvtd.pivot.qvtschedule.QVTscheduleFactory; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; import org.eclipse.qvtd.pivot.qvttemplate.CollectionTemplateExp; import org.eclipse.qvtd.pivot.qvttemplate.ObjectTemplateExp; @@ -424,7 +423,6 @@ public class RelationAnalysis extends RuleAnalysis List<@NonNull Node> headNodesList = QVTscheduleUtil.Internal.getHeadNodesList(region); headNodesList.clear(); Iterables.addAll(headNodesList, headNodes); - UtilityAnalysis.assignUtilities(scheduleManager, region); analyzeStrictness(); } @@ -665,15 +663,16 @@ public class RelationAnalysis extends RuleAnalysis return new RelationDispatchAnalysis(this, dispatchRegion); } - protected @NonNull InvocationAnalysis createOutgoingInvocationAnalysis(@NonNull RelationAnalysis invokedRelationAnalysis, @NonNull RelationCallExp relationCallExp, boolean isWhen) { + protected @NonNull InvocationAnalysis createOutgoingInvocationAnalysis(@NonNull RelationAnalysis invokedRelationAnalysis, @NonNull RelationCallExp relationCallExp, boolean isWhen, + @NonNull InitUtility initUtility, @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { RelationAnalysis invokedBaseRelationAnalysis = invokedRelationAnalysis.getBaseRelationAnalysis(); InvocationAnalysis invocationAnalysis; if (invokedBaseRelationAnalysis.getRule().isIsTopLevel()) { if (isWhen) { - invocationAnalysis = new TopWhenInvocationAnalysis(this, invokedRelationAnalysis); + invocationAnalysis = new TopWhenInvocationAnalysis(this, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } else { - invocationAnalysis = new TopWhereInvocationAnalysis(this, invokedRelationAnalysis); + invocationAnalysis = new TopWhereInvocationAnalysis(this, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } } else { @@ -682,18 +681,18 @@ public class RelationAnalysis extends RuleAnalysis boolean hasWhenAndWhereInvocations = hasWhenInvocations && hasWhereInvocations; if (isWhen) { if (hasWhenAndWhereInvocations) { - invocationAnalysis = new NonTopWhenAfterWhereInvocationAnalysis(this, invokedRelationAnalysis); + invocationAnalysis = new NonTopWhenAfterWhereInvocationAnalysis(this, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } else { - invocationAnalysis = new NonTopWhenOnlyInvocationAnalysis(this, invokedRelationAnalysis); + invocationAnalysis = new NonTopWhenOnlyInvocationAnalysis(this, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } } else { if (hasWhenAndWhereInvocations) { - invocationAnalysis = new NonTopWhereBeforeWhenInvocationAnalysis(this, invokedRelationAnalysis); + invocationAnalysis = new NonTopWhereBeforeWhenInvocationAnalysis(this, invokedRelationAnalysis, initUtility.getNullableUtility(), rootVariable2argumentNode); } else { - invocationAnalysis = new NonTopWhereOnlyInvocationAnalysis(this, invokedRelationAnalysis); + invocationAnalysis = new NonTopWhereOnlyInvocationAnalysis(this, invokedRelationAnalysis, initUtility.getNullableUtility(), rootVariable2argumentNode); } } } @@ -788,8 +787,32 @@ public class RelationAnalysis extends RuleAnalysis public @NonNull QVTrelationNameGenerator getNameGenerator() { return (QVTrelationNameGenerator) super.getNameGenerator(); } + /** + * Return the utility for a give variableDeclaration adjusting the optional multiplicity of the heads an optional + * when invocation to non-optional. (See Bug 499432) + */ + private @NonNull InitUtility getOptionallyMatchAtRootUtility(@NonNull VariableDeclaration variableDeclaration) { + boolean anyRequired = false; + boolean isRootVariable = false; + for (@NonNull VariableDeclaration rootVariable : QVTrelationUtil.getRootVariables(getRule())) { + if (rootVariable == variableDeclaration) { + isRootVariable = true; + } + if (rootVariable.isIsRequired()) { + anyRequired = true; + } + } + if (!isRootVariable) { // Non-root is not + return InitUtility.getRequiredInitUtility(variableDeclaration); // a root match + } + if (anyRequired) { // If any root cannot be null + return InitUtility.getRequiredInitUtility(variableDeclaration); // a match is required + } + return InitUtility.NON_NULL_MATCHED; // Match can be omitted + } - public @NonNull InvocationAnalysis getOutgoingInvocationAnalysis(@NonNull RelationAnalysis invokedRelationAnalysis, @NonNull RelationCallExp invocation, boolean isWhen) { + public @NonNull InvocationAnalysis getOutgoingInvocationAnalysis(@NonNull RelationAnalysis invokedRelationAnalysis, @NonNull RelationCallExp invocation, boolean isWhen, @NonNull InitUtility initUtility, + @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { Map<@NonNull RelationCallExp, @Nullable InvocationAnalysis> outgoingInvocationAnalyses = isWhen ? outgoingWhenInvocation2invocationAnalysis : outgoingWhereInvocation2invocationAnalysis; if (outgoingInvocationAnalyses != null) { InvocationAnalysis invocationAnalysis = outgoingInvocationAnalyses.get(invocation); @@ -797,7 +820,7 @@ public class RelationAnalysis extends RuleAnalysis return invocationAnalysis; } } - return createOutgoingInvocationAnalysis(invokedRelationAnalysis, invocation, isWhen); + return createOutgoingInvocationAnalysis(invokedRelationAnalysis, invocation, isWhen, initUtility, rootVariable2argumentNode); } protected @NonNull Set<@NonNull VariableDeclaration> getRealizedOutputVariables() { @@ -812,7 +835,7 @@ public class RelationAnalysis extends RuleAnalysis node = getReferenceNodeForSharedVariable((SharedVariable)variableDeclaration, null); } if (node == null) { - node = createOldNode(variableDeclaration); + node = createOldNode(InitUtility.getRequiredInitUtility(variableDeclaration), variableDeclaration); if (node.isThis()) { setThisNode(node); } @@ -850,7 +873,7 @@ public class RelationAnalysis extends RuleAnalysis return null; } } - ExpressionSynthesizer expressionSynthesizer2 = unconditionalExpressionSynthesizer.getExpressionSynthesizer(variable.isIsRequired()); + ExpressionSynthesizer expressionSynthesizer2 = rootExpressionSynthesizer.getRequiredExpressionSynthesizer(variable.isIsRequired()); Node bestInitNode = bestInitExpression.accept(expressionSynthesizer2); assert bestInitNode != null; if (variable.isIsRequired()) { @@ -878,7 +901,7 @@ public class RelationAnalysis extends RuleAnalysis ClassDatum initClassDatum = QVTscheduleUtil.getClassDatum(bestInitNode); ClassDatum variableClassDatum = scheduleManager.getClassDatum(variable); if (!QVTscheduleUtil.conformsTo(initClassDatum, variableClassDatum)) { - Node castNode = createOldNode(variable); + Node castNode = createOldNode(InitUtility.getRequiredInitUtility(variable), variable); expressionSynthesizer2.createCastEdge(bestInitNode, variableClassDatum, castNode); bestInitNode = castNode; } @@ -1104,20 +1127,19 @@ public class RelationAnalysis extends RuleAnalysis // Relation2DispatchClass relation2dispatchClass = getRule2TraceGroup().getBaseRelation2TraceGroup().getRule2DispatchClass(); ClassDatum classDatum = scheduleManager.getClassDatum(getTraceTypedModel(), relation2dispatchClass.getMiddleClass()); - Node dispatchNode = createPredicatedNode(QVTrelationNameGenerator.DISPATCHCLASS_SELF_NAME, classDatum, true); - dispatchNode.setUtility(Utility.DISPATCH); + Node dispatchNode = createPredicatedNode(InitUtility.DISPATCH, QVTrelationNameGenerator.DISPATCHCLASS_SELF_NAME, classDatum); Property doProperty = relation2dispatchClass.getDispatchClass2TraceProperty(relation).getTraceProperty(); - createNavigationEdge(dispatchNode, doProperty, traceNode, false); + createNavigationEdge(InitUtility.NON_NULL_MATCHED, dispatchNode, doProperty, traceNode, false); // // Set the trace node as the dispatch's result. // Property resultProperty = relation2dispatchClass.getResultProperty(); - createRealizedNavigationEdge(dispatchNode, resultProperty, traceNode, false); + createRealizedNavigationEdge(InitUtility.NON_NULL_MATCHED, dispatchNode, resultProperty, traceNode, false); // // Set the dispatch node success as true. // Property dispatchSuccessProperty = relation2dispatchClass.getDispatchSuccessProperty(); - createRealizedSuccess(dispatchNode, dispatchSuccessProperty, true); + createRealizedSuccess(InitUtility.NON_NULL_MATCHED, dispatchNode, dispatchSuccessProperty, true); // // dispatch node is the head. // @@ -1176,21 +1198,20 @@ public class RelationAnalysis extends RuleAnalysis Relation2MiddleType baseRelation2invocationInterface = baseRelation2traceGroup.getRule2InvocationInterface(); org.eclipse.ocl.pivot.Class baseInvocationClass = baseRelation2invocationInterface.getMiddleClass(); ClassDatum classDatum = scheduleManager.getClassDatum(scheduleManager.getTraceTypedModel(), baseInvocationClass); - Node invocationNode = createPredicatedNode(QVTrelationNameGenerator.DISPATCHCLASS_SELF_NAME, classDatum, true); - invocationNode.setUtility(Utility.DISPATCH); + Node invocationNode = createPredicatedNode(InitUtility.NON_NULL_MATCHED, QVTrelationNameGenerator.DISPATCHCLASS_SELF_NAME, classDatum); region.getHeadNodes().add(invocationNode); invocationNode.setHead(); Relation2ResultProperty relation2resultProperty = baseRelation2invocationInterface.basicGetRelation2ResultProperty(); if (relation2resultProperty != null) { Property resultProperty = relation2resultProperty.getTraceProperty(); - createRealizedNavigationEdge(invocationNode, resultProperty, traceNode, false); + rootExpressionSynthesizer.createRealizedNavigationEdge(invocationNode, resultProperty, traceNode, false); } for (@NonNull VariableDeclaration rootVariable : QVTrelationUtil.getRootVariables(relation)) { Node rootNode = region.getNode(rootVariable); assert rootNode != null; VariableDeclaration baseRootVariable = QVTrelationUtil.getOverriddenVariable(baseRelation, rootVariable); Property traceProperty = baseRelation2invocationInterface.getTraceProperty(baseRootVariable); - createNavigationEdge(invocationNode, traceProperty, rootNode, false); + rootExpressionSynthesizer.createNavigationEdge(invocationNode, traceProperty, rootNode, false); } } else { @@ -1235,20 +1256,20 @@ public class RelationAnalysis extends RuleAnalysis Node node = property2node.get(property); assert node != null; PropertyDatum propertyDatum = scheduleManager.getPropertyDatum(classDatum, property); - createKeyPartEdge(node, propertyDatum, keyNode); + createKeyPartEdge(keyNode.getInitUtility(), node, propertyDatum, keyNode); } return null; } public @NonNull Node synthesizeKeyTemplatePart(@NonNull PropertyTemplateItem propertyTemplateItem) { OCLExpression targetExpression = QVTrelationUtil.getOwnedValue(propertyTemplateItem); - Node partNode = targetExpression.accept(unconditionalExpressionSynthesizer); + Node partNode = targetExpression.accept(rootExpressionSynthesizer); assert partNode != null; return partNode; } protected void synthesizeMultipleInputCollectionTemplate(@NonNull CollectionTemplateExp collectionTemplateExp) { - Node residueNode = collectionTemplateExp.accept(unconditionalExpressionSynthesizer); + Node residueNode = collectionTemplateExp.accept(rootExpressionSynthesizer); assert residueNode != null; /* EObject eContainer = collectionTemplateExp.eContainer(); @@ -1271,44 +1292,44 @@ public class RelationAnalysis extends RuleAnalysis if (memberNode != null) { Node selfNode = residueNode; assert selfNode != null; - residueNode = createOperationCallNode(isUnconditional(member), null, collectionExcludingOperation, collectionTemplateExp, residueNode, memberNode); - createOperationSelfEdge(selfNode, QVTrelationUtil.getType(collectionExcludingOperation), residueNode); - createOperationParameterEdge(memberNode, QVTrelationUtil.getOwnedParameter(collectionExcludingOperation, 0), -1, residueNode); + residueNode = createOperationCallNode(InitUtility.NON_NULL_MATCHED, null, collectionExcludingOperation, collectionTemplateExp, residueNode, memberNode); + createOperationSelfEdge(selfNode.getInitUtility(), selfNode, QVTrelationUtil.getType(collectionExcludingOperation), residueNode); + createOperationParameterEdge(memberNode.getInitUtility(), memberNode, QVTrelationUtil.getOwnedParameter(collectionExcludingOperation, 0), -1, residueNode); } - memberNode = member.accept(unconditionalExpressionSynthesizer); + memberNode = member.accept(rootExpressionSynthesizer); assert memberNode != null; // memberNodes.add(memberNode); // createPredicateEdge(collectionNode, "head-" + i++, memberNode); - createPredicateEdge(residueNode, INCLUDES_NAME, memberNode); + createPredicateEdge(InitUtility.NON_NULL_MATCHED, residueNode, INCLUDES_NAME, memberNode); } Variable rest = collectionTemplateExp.getRest(); if ((rest != null) && !rest.isIsImplicit()) { if (memberNode != null) { Node selfNode = residueNode; assert selfNode != null; - residueNode = createOperationCallNode(isUnconditional(rest), null, collectionExcludingOperation, collectionTemplateExp, residueNode, memberNode); - createOperationSelfEdge(selfNode, QVTrelationUtil.getType(collectionExcludingOperation), residueNode); - createOperationParameterEdge(memberNode, QVTrelationUtil.getOwnedParameter(collectionExcludingOperation, 0), -1, residueNode); + residueNode = createOperationCallNode(InitUtility.NON_NULL_MATCHED, null, collectionExcludingOperation, collectionTemplateExp, residueNode, memberNode); + createOperationSelfEdge(selfNode.getInitUtility(), selfNode, QVTrelationUtil.getType(collectionExcludingOperation), residueNode); + createOperationParameterEdge(memberNode.getInitUtility(), memberNode, QVTrelationUtil.getOwnedParameter(collectionExcludingOperation, 0), -1, residueNode); } - Node restNode = rest.accept(unconditionalExpressionSynthesizer); + Node restNode = rest.accept(rootExpressionSynthesizer); assert restNode != null; - createEqualsEdge(residueNode, restNode); + createEqualsEdge(InitUtility.NON_NULL_MATCHED, residueNode, restNode); } if (rest == null) { Operation collectionIsEmptyOperation = scheduleManager.getStandardLibraryHelper().getCollectionIsEmptyOperation(); - Node isEmptyNode = createOperationCallNode(isUnconditional(collectionTemplateExp), null, collectionIsEmptyOperation, collectionTemplateExp, residueNode); - createPredicatedStepNode(isEmptyNode, false); + Node isEmptyNode = createOperationCallNode(InitUtility.NON_NULL_MATCHED, null, collectionIsEmptyOperation, collectionTemplateExp, residueNode); + createPredicatedStepNode(InitUtility.NON_NULL_MATCHED, isEmptyNode); } } protected boolean synthesizeNavigationCallEqualsPredicate(@NonNull NavigationCallExp navExpression, @NonNull OCLExpression valueExpression) { - Node valueNode = valueExpression.accept(unconditionalExpressionSynthesizer); + Node valueNode = valueExpression.accept(rootExpressionSynthesizer); assert valueNode != null; OCLExpression sourceExpression = QVTbaseUtil.getOwnedSource(navExpression); - Node sourceNode = sourceExpression.accept(unconditionalExpressionSynthesizer); + Node sourceNode = sourceExpression.accept(rootExpressionSynthesizer); assert sourceNode != null; Property source2targetProperty = QVTbaseUtil.getReferredProperty(navExpression); - createNavigationEdge(sourceNode, source2targetProperty, valueNode, false); + rootExpressionSynthesizer.createNavigationEdge(sourceNode, source2targetProperty, valueNode, false); return true; } @@ -1326,21 +1347,21 @@ public class RelationAnalysis extends RuleAnalysis if (targetNode != null) { boolean isPartial = scheduleManager.computeIsPartial(targetNode, source2targetProperty); if (scheduleManager.isOutputInRule(QVTrelationUtil.getContainingRule(propertyTemplateItem), sourceVariable) /*&& !propertyTemplateItem.isCheckOnly()*/) { - createRealizedNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); + rootExpressionSynthesizer.createRealizedNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); } else { - createNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); + rootExpressionSynthesizer.createNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); } } } else { - Node targetNode = unconditionalExpressionSynthesizer.getExpressionSynthesizer(source2targetProperty.isIsRequired()).synthesize(targetExpression); + Node targetNode = rootExpressionSynthesizer.getRequiredExpressionSynthesizer(source2targetProperty.isIsRequired()).synthesize(targetExpression); boolean isPartial = scheduleManager.computeIsPartial(targetNode, source2targetProperty); if (scheduleManager.isOutputInRule(QVTbaseUtil.getContainingRule(sourceVariable), sourceVariable) /*&& !propertyTemplateItem.isCheckOnly()*/) { - createRealizedNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); + rootExpressionSynthesizer.createRealizedNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); } else { - createNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); + rootExpressionSynthesizer.createNavigationEdge(sourceNode, source2targetProperty, targetNode, isPartial); } } return targetExpression; @@ -1389,24 +1410,24 @@ public class RelationAnalysis extends RuleAnalysis PropertyTemplateItem propertyTemplateItem = (PropertyTemplateItem)eContainer; Property source2target = QVTrelationUtil.getReferredProperty(propertyTemplateItem); ObjectTemplateExp objectTemplateExp = QVTrelationUtil.getOwningObjectTemplateExp(propertyTemplateItem); - Node sourceNode = objectTemplateExp.accept(unconditionalExpressionSynthesizer); + Node sourceNode = objectTemplateExp.accept(rootExpressionSynthesizer); assert sourceNode != null; for (@NonNull OCLExpression member : QVTrelationUtil.getOwnedMembers(collectionTemplateExp)) { - Node memberNode = member.accept(unconditionalExpressionSynthesizer); + Node memberNode = member.accept(rootExpressionSynthesizer); assert memberNode != null; - createRealizedNavigationEdge(sourceNode, source2target, memberNode, true); + rootExpressionSynthesizer.createRealizedNavigationEdge(sourceNode, source2target, memberNode, true); } } else { // FIXME can this ever happen ? - Node collectionNode = collectionTemplateExp.accept(unconditionalExpressionSynthesizer); + Node collectionNode = collectionTemplateExp.accept(rootExpressionSynthesizer); assert collectionNode != null; for (@NonNull OCLExpression member : QVTrelationUtil.getOwnedMembers(collectionTemplateExp)) { - Node memberNode = member.accept(unconditionalExpressionSynthesizer); + Node memberNode = member.accept(rootExpressionSynthesizer); assert memberNode != null; // memberNodes.add(memberNode); // createPredicateEdge(collectionNode, "head-" + i++, memberNode); - createRealizedIncludesEdge(collectionNode, memberNode); + createRealizedIncludesEdge(memberNode.getInitUtility(), collectionNode, memberNode); } } } @@ -1428,14 +1449,14 @@ public class RelationAnalysis extends RuleAnalysis Relation2MiddleType overridingRelation2TraceInterface = overridingrelation2traceGroup.getRule2TraceInterface(); Relation2MiddleType overridingRelation2TraceClass = overridingrelation2traceGroup.getRule2TraceClass(); ClassDatum overridingClassDatum = scheduleManager2.getClassDatum(traceTypedModel, overridingRelation2TraceInterface.getMiddleClass()); - Node guardNode = createPredicatedNode("not_" + overridingRelation.getName(), overridingClassDatum, true); + Node guardNode = createPredicatedNode(InitUtility.NON_NULL_MATCHED, "not_" + overridingRelation.getName(), overridingClassDatum); Property globalSuccessProperty = overridingRelation2TraceClass.getGlobalSuccessProperty(); - createPredicatedSuccess(guardNode, globalSuccessProperty, false); + createPredicatedSuccess(InitUtility.NON_NULL_MATCHED, guardNode, globalSuccessProperty, false); if (dispatchNode != null) { Relation2DispatchClass relation2dispatchClass = overriddenRelationAnalysis.getRule2TraceGroup().getRule2DispatchClass(); DispatchClass2TraceProperty dispatchClass2TraceProperty = relation2dispatchClass.getDispatchClass2TraceProperty(overridingRelation); Property guardProperty = dispatchClass2TraceProperty.getTraceProperty(); - createNavigationEdge(dispatchNode, guardProperty, guardNode, false); + createNavigationEdge(InitUtility.NON_NULL_MATCHED, dispatchNode, guardProperty, guardNode, false); } if (isWhere /*|| scheduleManager2.getDomainUsage(rootVariable).isInput()*/) { for (@NonNull VariableDeclaration rootVariable : QVTrelationUtil.getRootVariables(relation)) { @@ -1443,7 +1464,7 @@ public class RelationAnalysis extends RuleAnalysis VariableDeclaration overridingRootVariable = QVTrelationUtil.getOverriddenVariable(overridingRelation, rootVariable); Property invocationProperty = overridingRelation2TraceInterface.getTraceProperty(overridingRootVariable); boolean isPartial = scheduleManager.computeIsPartial(rootVariableNode, invocationProperty); - createNavigationEdge(guardNode, invocationProperty, rootVariableNode, isPartial); + createNavigationEdge(rootVariableNode.getInitUtility(), guardNode, invocationProperty, rootVariableNode, isPartial); } } } @@ -1524,7 +1545,7 @@ public class RelationAnalysis extends RuleAnalysis if (synthesizeEqualsPredicate(predicateExpression)) { return; } - Node resultNode = predicateExpression.accept(unconditionalExpressionSynthesizer); //.getConditionalExpressionSynthesizer()); // See Bug 547263 + Node resultNode = predicateExpression.accept(rootExpressionSynthesizer.getExpressionSynthesizer(InitUtility.NON_NULL_MATCHED)); //.getConditionalExpressionSynthesizer()); // See Bug 547263 /* if (resultNode != null) { ClassDatum classDatum = QVTscheduleUtil.getClassDatum(resultNode); if (!resultNode.isRequired() || (classDatum != scheduleManager.getBooleanClassDatum())) { @@ -1537,16 +1558,16 @@ public class RelationAnalysis extends RuleAnalysis // ClassDatum classDatum = QVTscheduleUtil.getClassDatum(resultNode); // if (!resultNode.isRequired() || (classDatum != scheduleManager.getBooleanClassDatum())) { if (!resultNode.isRequired()) { - Node trueNode = createBooleanLiteralNode(true); - createPredicateEdge(resultNode, null, trueNode); + Node trueNode = createBooleanLiteralNode(resultNode.getInitUtility(), true); + createPredicateEdge(resultNode.getInitUtility(), resultNode, null, trueNode); } // else if (classDatum != scheduleManager.getBooleanClassDatum()) { // Node trueNode = createBooleanLiteralNode(true); // createPredicateEdge(resultNode, null, trueNode); // } else if (!(resultNode instanceof BooleanLiteralNode)) { - Node trueNode = createBooleanLiteralNode(true); - createPredicateEdge(resultNode, null, trueNode); + Node trueNode = createBooleanLiteralNode(resultNode.getInitUtility(), true); + createPredicateEdge(resultNode.getInitUtility(), resultNode, null, trueNode); } } } @@ -1635,11 +1656,11 @@ public class RelationAnalysis extends RuleAnalysis PropertyTemplateItem propertyTemplateItem = (PropertyTemplateItem)eContainer; Property source2target = QVTrelationUtil.getReferredProperty(propertyTemplateItem); ObjectTemplateExp objectTemplateExp = QVTrelationUtil.getOwningObjectTemplateExp(propertyTemplateItem); - Node sourceNode = objectTemplateExp.accept(unconditionalExpressionSynthesizer); + Node sourceNode = objectTemplateExp.accept(rootExpressionSynthesizer); assert sourceNode != null; - Node memberNode = members.get(0).accept(unconditionalExpressionSynthesizer); + Node memberNode = members.get(0).accept(rootExpressionSynthesizer); assert memberNode != null; - createNavigationEdge(sourceNode, source2target, memberNode, true); + rootExpressionSynthesizer.createNavigationEdge(sourceNode, source2target, memberNode, true); return true; } @@ -1665,10 +1686,10 @@ public class RelationAnalysis extends RuleAnalysis assert targetNode != null; boolean isPartial = scheduleManager.computeIsPartial(dispatchNode, traceProperty); if (isInput) { - createNavigationEdge(dispatchNode, traceProperty, targetNode, isPartial); + createNavigationEdge(targetNode.getInitUtility(), dispatchNode, traceProperty, targetNode, isPartial); } else { - createRealizedNavigationEdge(dispatchNode, traceProperty, targetNode, isPartial); + createRealizedNavigationEdge(targetNode.getInitUtility(), dispatchNode, traceProperty, targetNode, isPartial); } } } @@ -1683,7 +1704,7 @@ public class RelationAnalysis extends RuleAnalysis assert targetNode != null; if (!rootVariables.contains(tracedVariable)) { boolean isPartial = scheduleManager.computeIsPartial(targetNode, traceProperty); - createRealizedNavigationEdge(traceNode, traceProperty, targetNode, isPartial); + createRealizedNavigationEdge(targetNode.getInitUtility(), traceNode, traceProperty, targetNode, isPartial); } } } @@ -1706,10 +1727,10 @@ public class RelationAnalysis extends RuleAnalysis assert targetNode != null; boolean isPartial = scheduleManager.computeIsPartial(traceNode, traceProperty); if (hasPredicatedTrace && rootVariables.contains(tracedVariable)) { - createNavigationEdge(traceNode, traceProperty, targetNode, isPartial); + createNavigationEdge(InitUtility.getRequiredInitUtility(traceProperty), traceNode, traceProperty, targetNode, isPartial); } else { - createRealizedNavigationEdge(traceNode, traceProperty, targetNode, isPartial); + createRealizedNavigationEdge(InitUtility.getRequiredInitUtility(traceProperty), traceNode, traceProperty, targetNode, isPartial); } } } @@ -1794,7 +1815,7 @@ public class RelationAnalysis extends RuleAnalysis protected void synthesizeTraceGlobalSuccessAssignment(@NonNull Relation2TraceGroup relation2traceGroup, @NonNull Node traceNode) { Element2MiddleProperty relation2globalSuccessProperty = relation2traceGroup.basicGetRelation2GlobalSuccessProperty(); if (relation2globalSuccessProperty != null) { - createRealizedSuccess(traceNode, relation2globalSuccessProperty.getTraceProperty(), null); + createRealizedSuccess(InitUtility.NON_NULL_MATCHED, traceNode, relation2globalSuccessProperty.getTraceProperty(), null); } } @@ -1815,11 +1836,11 @@ public class RelationAnalysis extends RuleAnalysis Node traceNode; boolean hasOverrides = QVTrelationUtil.hasOverrides(relation); if (hasOverrides) { - traceNode = createOldNode(traceVariable); + traceNode = createOldNode(InitUtility.TRACE, traceVariable); } else if (!relation.isIsTopLevel()) { // if (hasOverrides) { - traceNode = createOldNode(traceVariable); + traceNode = createOldNode(InitUtility.TRACE, traceVariable); // DomainUsage domainUsage = scheduleManager.getDomainUsage(traceVariable); // boolean isEnforceable = domainUsage.isOutput() || domainUsage.isMiddle(); // Role phase = isEnforceable ? Role.PREDICATED : Role.LOADED; @@ -1853,13 +1874,12 @@ public class RelationAnalysis extends RuleAnalysis } else { boolean hasPredicatedTrace = (incomingWhereInvocation2invocationAnalysis != null) && !hasOverrides; - traceNode = hasPredicatedTrace ? createOldNode(traceVariable) : createRealizedStepNode(traceVariable); + traceNode = hasPredicatedTrace ? createOldNode(InitUtility.TRACE, traceVariable) : createRealizedStepNode(InitUtility.TRACE, traceVariable); if (!getRule().isIsTopLevel()) { region.getHeadNodes().clear(); // region.getHeadNodes().add(traceNode); } } - traceNode.setUtility(Utility.TRACE); return traceNode; } @@ -1878,21 +1898,22 @@ public class RelationAnalysis extends RuleAnalysis } else if (getKeyedOutputVariables().contains(variableDeclaration)) { boolean isUnconditional = true; - createKeyedNode(isUnconditional, QVTrelationUtil.getName(variableDeclaration), variableDeclaration); + createKeyedNode(InitUtility.NON_NULL_MATCHED, QVTrelationUtil.getName(variableDeclaration), variableDeclaration); return; // keyed object created by synthesizeKeyedObject } else if (getTopWhenedOutputVariables().contains(variableDeclaration)) { - createOldNode(variableDeclaration); // when output is created by the invoked when + createOldNode(InitUtility.getRequiredInitUtility(variableDeclaration), variableDeclaration); // when output is created by the invoked when } else if (getNonTopWhenedOutputVariables().contains(variableDeclaration)) { - createOldNode(variableDeclaration); // when output is created by the invoked when + createOldNode(InitUtility.getRequiredInitUtility(variableDeclaration), variableDeclaration); // when output is created by the invoked when // createRealizedStepNode(variableDeclaration); // when output is created by the invoker } else if (hasIncomingWhereInvocations() && Iterables.contains(QVTrelationUtil.getRootVariables(getRule()), variableDeclaration)) { - createOldNode(variableDeclaration); // where 'output' is created by invoker + createOldNode(InitUtility.getRequiredInitUtility(variableDeclaration), variableDeclaration); // where 'output' is created by invoker } else if (getRealizedOutputVariables().contains(variableDeclaration)) { - createRealizedStepNode(variableDeclaration); + InitUtility utility = getOptionallyMatchAtRootUtility(variableDeclaration); + createRealizedStepNode(utility, variableDeclaration); } else { if (variableDeclaration instanceof TemplateVariable) { @@ -1902,7 +1923,8 @@ public class RelationAnalysis extends RuleAnalysis return; // CollectionTemplateExp variables would be bloat // } } - createOldNode(variableDeclaration); + InitUtility utility = getOptionallyMatchAtRootUtility(variableDeclaration); + createOldNode(utility, variableDeclaration); } else if (variableDeclaration instanceof SharedVariable) { SharedVariable sharedVariable = (SharedVariable)variableDeclaration; @@ -1914,11 +1936,13 @@ public class RelationAnalysis extends RuleAnalysis } } else { - createOldNode(variableDeclaration); // Never happens + InitUtility utility = getOptionallyMatchAtRootUtility(variableDeclaration); + createOldNode(utility, variableDeclaration); // Never happens } } } + protected boolean synthesizeVariableEqualsPredicate(@NonNull VariableDeclaration variable, @NonNull OCLExpression valueExp) { Node variableNode = region.getNode(variable); if (variableNode == null) { @@ -1929,10 +1953,10 @@ public class RelationAnalysis extends RuleAnalysis return true; } } - variableNode = variable.accept(unconditionalExpressionSynthesizer); - Node expressionNode = valueExp.accept(unconditionalExpressionSynthesizer); + variableNode = variable.accept(rootExpressionSynthesizer); + Node expressionNode = valueExp.accept(rootExpressionSynthesizer); assert (variableNode != null) && (expressionNode != null); - createEqualsEdge(expressionNode, variableNode); + createEqualsEdge(InitUtility.NON_NULL_MATCHED, expressionNode, variableNode); return true; } }
\ No newline at end of file diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationDispatchAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationDispatchAnalysis.java index 2db108be2..87984e06c 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationDispatchAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationDispatchAnalysis.java @@ -16,7 +16,6 @@ import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.Property; import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.RegionHelper; -import org.eclipse.qvtd.compiler.internal.qvtb2qvts.UtilityAnalysis; import org.eclipse.qvtd.compiler.internal.qvtr2qvts.trace.DispatchClass2TraceProperty; import org.eclipse.qvtd.compiler.internal.qvtr2qvts.trace.Relation2DispatchClass; import org.eclipse.qvtd.compiler.internal.qvtr2qvts.trace.Relation2TraceClass; @@ -31,7 +30,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.DispatchRegion; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.RuleRegion; import org.eclipse.qvtd.pivot.qvtschedule.VariableNode; -import org.eclipse.qvtd.pivot.qvtschedule.Node.Utility; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * A RelationDispatchAnalysis assists in the synthesis of the dispatch for an override hierarchy. @@ -57,9 +56,9 @@ public class RelationDispatchAnalysis extends RegionHelper<@NonNull RuleRegion> Relation2TraceClass relation2TraceClass = scheduleManager.getRuleAnalysis(relation).getRule2TraceGroup().getRule2TraceClass(); TypedModel traceTypedModel = relationAnalysis.getTraceTypedModel(); ClassDatum dispatchedClassDatum = scheduleManager.getClassDatum(traceTypedModel, relation2TraceClass.getMiddleClass()); - Node dispatchedNode = createRealizedNode(getName(relation), dispatchedClassDatum, true); + Node dispatchedNode = createRealizedNode(InitUtility.NON_NULL_MATCHED, getName(relation), dispatchedClassDatum); DispatchClass2TraceProperty dispatchClass2traceProperty = relation2dispatchClass.getDispatchClass2TraceProperty(relation); - createRealizedNavigationEdge(traceNode, dispatchClass2traceProperty.getTraceProperty(), dispatchedNode, false); + createRealizedNavigationEdge(InitUtility.NON_NULL_MATCHED, traceNode, dispatchClass2traceProperty.getTraceProperty(), dispatchedNode, false); } for (@NonNull Relation overridingRelation : QVTrelationUtil.getOverrides(relation)) { synthesizeDispatchHierarchy(traceNode, relation2dispatchClass, overridingRelation); @@ -85,14 +84,6 @@ public class RelationDispatchAnalysis extends RegionHelper<@NonNull RuleRegion> // Create the trace node assignments to pattern nodes // synthesizeDispatchHierarchy(traceNode, relation2dispatchClass, relation); - // - // - // - // Iterable<@NonNull Node> headNodes = RuleHeadAnalysis.computeRuleHeadNodes(scheduleManager, region, null); - // List<@NonNull Node> headNodesList = QVTscheduleUtil.Internal.getHeadNodesList(region); - // headNodesList.clear(); - // Iterables.addAll(headNodesList, headNodes); - UtilityAnalysis.assignUtilities(scheduleManager, region); } /** @@ -110,9 +101,9 @@ public class RelationDispatchAnalysis extends RegionHelper<@NonNull RuleRegion> // VariableDeclaration2TraceProperty variableDeclaration2traceInterfaceProperty = rule2traceInterface.getVariableDeclaration2TraceProperty(variable); Property traceClassProperty = variableDeclaration2traceClassProperty.getTraceProperty(); // Property traceInterfaceProperty = variableDeclaration2traceInterfaceProperty.getTraceProperty(); - Node targetNode = createOldNode(variable); + Node targetNode = createOldNode(InitUtility.getRequiredInitUtility(variable), variable); boolean isPartial = scheduleManager.computeIsPartial(targetNode, traceClassProperty); - createNavigationEdge(traceNode, traceClassProperty, targetNode, isPartial); + createNavigationEdge(targetNode.getInitUtility(), traceNode, traceClassProperty, targetNode, isPartial); if (isTopLevel) { region.getHeadNodes().add(targetNode); targetNode.setHead(); @@ -140,13 +131,11 @@ public class RelationDispatchAnalysis extends RegionHelper<@NonNull RuleRegion> TypedModel traceTypedModel = relationAnalysis.getTraceTypedModel(); ClassDatum dispatchedClassDatum = scheduleManager.getClassDatum(traceTypedModel, relation2dispatchClass.getMiddleClass()); if (relation.isIsTopLevel()) { - VariableNode realizedDispatchNode = createRealizedNode(QVTrelationNameGenerator.DISPATCHCLASS_SELF_NAME, dispatchedClassDatum, true); - realizedDispatchNode.setUtility(Utility.TRACE); + VariableNode realizedDispatchNode = createRealizedNode(InitUtility.DISPATCH, QVTrelationNameGenerator.DISPATCHCLASS_SELF_NAME, dispatchedClassDatum); return realizedDispatchNode; } else { - Node predicatedDispatchNode = createPredicatedNode(QVTrelationNameGenerator.DISPATCHCLASS_SELF_NAME, dispatchedClassDatum, true); - predicatedDispatchNode.setUtility(Utility.TRACE); + Node predicatedDispatchNode = createPredicatedNode(InitUtility.TRACE, QVTrelationNameGenerator.DISPATCHCLASS_SELF_NAME, dispatchedClassDatum); region.getHeadNodes().add(predicatedDispatchNode); predicatedDispatchNode.setHead(); return predicatedDispatchNode; diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationVerdictAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationVerdictAnalysis.java index dbc4ea13d..b22f09ac1 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationVerdictAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/RelationVerdictAnalysis.java @@ -15,7 +15,6 @@ import java.util.List; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.Property; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.RegionHelper; -import org.eclipse.qvtd.compiler.internal.qvtb2qvts.UtilityAnalysis; import org.eclipse.qvtd.compiler.internal.qvtr2qvts.trace.DispatchClass2TraceProperty; import org.eclipse.qvtd.compiler.internal.qvtr2qvts.trace.Relation2DispatchClass; import org.eclipse.qvtd.compiler.internal.qvtr2qvts.trace.Relation2MiddleType; @@ -28,6 +27,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.RuleRegion; import org.eclipse.qvtd.pivot.qvtschedule.VerdictRegion; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * A RelationVerdictAnalysis assists in the synthesis of the base region that assigns the false success once all overrides have failed. @@ -57,17 +57,17 @@ public class RelationVerdictAnalysis extends RegionHelper<@NonNull RuleRegion> Relation2MiddleType relation2TraceInterface = relationAnalysis.getRule2TraceGroup().getBaseRelation2TraceGroup().getRule2TraceInterface(); TypedModel traceTypedModel = relationAnalysis.getTraceTypedModel(); ClassDatum dispatchedClassDatum = scheduleManager.getClassDatum(traceTypedModel, relation2TraceClass.getMiddleClass()); - Node dispatchedNode = createPredicatedNode(getName(relation), dispatchedClassDatum, true); + Node dispatchedNode = createPredicatedNode(InitUtility.NON_NULL_MATCHED, getName(relation), dispatchedClassDatum); // // Reached by the appropriate dispatch navigation. // DispatchClass2TraceProperty dispatchClass2traceProperty = relation2dispatchClass.getDispatchClass2TraceProperty(relation); - createNavigationEdge(traceNode, dispatchClass2traceProperty.getTraceProperty(), dispatchedNode, false); + createNavigationEdge(InitUtility.NON_NULL_MATCHED, traceNode, dispatchClass2traceProperty.getTraceProperty(), dispatchedNode, false); // // Require the overriding relation to have failed. // Property successProperty = relation2TraceInterface.getGlobalSuccessProperty(); - createPredicatedSuccess(dispatchedNode, successProperty, false); + createPredicatedSuccess(InitUtility.NON_NULL_MATCHED, dispatchedNode, successProperty, false); } for (@NonNull Relation overridingRelation : QVTrelationUtil.getOverrides(relation)) { synthesizeDispatchHierarchy(traceNode, relation2dispatchClass, overridingRelation); @@ -89,8 +89,6 @@ public class RelationVerdictAnalysis extends RegionHelper<@NonNull RuleRegion> // Create the trace node assignments to pattern nodes // synthesizeDispatchHierarchy(traceNode, relation2dispatchClass, relation); - // - UtilityAnalysis.assignUtilities(scheduleManager, region); } /** @@ -100,12 +98,12 @@ public class RelationVerdictAnalysis extends RegionHelper<@NonNull RuleRegion> QVTrelationScheduleManager scheduleManager =(QVTrelationScheduleManager)getScheduleManager(); TypedModel traceTypedModel = scheduleManager.getTraceTypedModel(); ClassDatum dispatchedClassDatum = scheduleManager.getClassDatum(traceTypedModel, relation2dispatchClass.getMiddleClass()); - Node traceNode = createPredicatedNode(getName(relation), dispatchedClassDatum, true); + Node traceNode = createPredicatedNode(InitUtility.NON_NULL_MATCHED, getName(relation), dispatchedClassDatum); region.getHeadNodes().add(traceNode); traceNode.setHead(); Property successProperty = relation2dispatchClass.getDispatchSuccessProperty(); - createRealizedSuccess(traceNode, successProperty, false); + createRealizedSuccess(InitUtility.NON_NULL_MATCHED, traceNode, successProperty, false); return traceNode; } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/TopWhenInvocationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/TopWhenInvocationAnalysis.java index a2639d642..588742f77 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/TopWhenInvocationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/TopWhenInvocationAnalysis.java @@ -10,32 +10,25 @@ *******************************************************************************/ package org.eclipse.qvtd.compiler.internal.qvtr2qvts; +import java.util.Map; + import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.pivot.qvtrelation.Relation; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.Node; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * A TopWhenInvocationAnalysis identifies the invocation of a top Relation by a when clause in another. */ public class TopWhenInvocationAnalysis extends AbstractWhenInvocationAnalysis { - public TopWhenInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis) { - super(invokingRelationAnalysis, invokedRelationAnalysis); - } - - @Override - protected @NonNull Node createInvocationNode(@NonNull String name, @NonNull ClassDatum classDatum, boolean isMatched) { - return invokingRelationAnalysis.createPredicatedNode(name, classDatum, isMatched); - } - - /** - * Return true unless a non-match is permitted for null input to null output. (See Bug 499432) + * Return true unless a non-match is permitted and used for null input to null output. (See Bug 499432) */ - @Override - protected boolean isMatched() { + // @Override + private static @NonNull InitUtility resolveInitUtility(@NonNull InitUtility initUtility, @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { boolean anyRequired = false; boolean anyOmitted = false; for (@NonNull VariableDeclaration rootVariable : rootVariable2argumentNode.keySet()) { @@ -49,12 +42,22 @@ public class TopWhenInvocationAnalysis extends AbstractWhenInvocationAnalysis } } if (anyRequired) { // If any root cannot be null - return true; // a match is required + return initUtility; // a match is required } if (!anyOmitted) { // If nothing omitted - return true; // a match is required + return initUtility; // a match is required } - return false; // Match can be omitted + return initUtility.isConditional() ? InitUtility.NULLABLE_CONDITIONAL: InitUtility.NULLABLE_MATCHED; // Match can be omitted + } + + public TopWhenInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis, + @NonNull InitUtility initUtility, @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { + super(invokingRelationAnalysis, invokedRelationAnalysis, resolveInitUtility(initUtility, rootVariable2argumentNode), rootVariable2argumentNode); + } + + @Override + protected @NonNull Node createInvocationNode(@NonNull String name, @NonNull ClassDatum classDatum) { + return invokingRelationAnalysis.createPredicatedNode(initUtility, name, classDatum); } @Override diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/TopWhereInvocationAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/TopWhereInvocationAnalysis.java index 19be4a7ea..82358cfa1 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/TopWhereInvocationAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/TopWhereInvocationAnalysis.java @@ -10,10 +10,14 @@ *******************************************************************************/ package org.eclipse.qvtd.compiler.internal.qvtr2qvts; +import java.util.Map; + import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.Property; +import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * A TopWhereInvocationAnalysis identifies the invocation of a top Relation by a where clause in another. @@ -23,8 +27,9 @@ import org.eclipse.qvtd.pivot.qvtschedule.Node; */ public class TopWhereInvocationAnalysis extends AbstractInvocationAnalysis { - public TopWhereInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis) { - super(invokingRelationAnalysis, invokedRelationAnalysis); + public TopWhereInvocationAnalysis(@NonNull RelationAnalysis invokingRelationAnalysis, @NonNull RelationAnalysis invokedRelationAnalysis, + @NonNull InitUtility initUtility, @NonNull Map<@NonNull VariableDeclaration, @NonNull Node> rootVariable2argumentNode) { + super(invokingRelationAnalysis, invokedRelationAnalysis, initUtility, rootVariable2argumentNode); } @Override @@ -42,14 +47,6 @@ public class TopWhereInvocationAnalysis extends AbstractInvocationAnalysis throw new UnsupportedOperationException(); // Cannot happen synthesizeInvocationNodes is empty. } - /** - * Return false since a where match is always optional. - */ - @Override - protected boolean isMatched() { - return false; - } - @Override public boolean isTop() { return true; diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/trace/Relation2TraceClass.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/trace/Relation2TraceClass.java index d245bc8aa..fd4f9dc21 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/trace/Relation2TraceClass.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtr2qvts/trace/Relation2TraceClass.java @@ -138,10 +138,10 @@ public class Relation2TraceClass extends AbstractRelation2MiddleType if (node.isThis()) { ; // Do not trace this } - else if (node.isPattern() && node.isMatched()) { + else if (node.isPattern() && !node.isConditional()) { createVariableDeclaration2TraceProperty(node, rootVariables, allHeadGroupNodes, manyTracesPerHead); } - else if (/*node.isPattern() &&*/ node.isMatched() && !node.isConstant()) { + else if (/*node.isPattern() &&*/ !node.isConditional() && !node.isConstant()) { createVariableDeclaration2TraceProperty(node, rootVariables, allHeadGroupNodes, manyTracesPerHead); } } @@ -442,7 +442,9 @@ public class Relation2TraceClass extends AbstractRelation2MiddleType } Relation2TraceGroup invokedRule2TraceGroup = invocationAnalysis.getInvokedRelationAnalysis().getRule2TraceGroup().getBaseRelation2TraceGroup(); String nameHint = relation2traceGroup.getNameGenerator().createInvocationTraceProperty(invokedRule2TraceGroup.getRule()); - Invocation2TraceProperty relation2traceProperty = new Invocation2TraceProperty(this, nameHint, invokedRule2TraceGroup.getInvocationClass(), invocationAnalysis.isWhen() && !invocationAnalysis.isTop()); + boolean isRequired = !invocationAnalysis.isOptional(); + org.eclipse.ocl.pivot.Class invocationClass = invokedRule2TraceGroup.getInvocationClass(); + Invocation2TraceProperty relation2traceProperty = new Invocation2TraceProperty(this, nameHint, invocationClass, isRequired); Invocation2TraceProperty oldRelation2traceProperty = invocationAnalysis2relation2traceProperty2.put(invocationAnalysis, relation2traceProperty); assert oldRelation2traceProperty == null; return relation2traceProperty; diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/BasicPartition2Mapping.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/BasicPartition2Mapping.java index 0dcbfd5cb..b3380786c 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/BasicPartition2Mapping.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/BasicPartition2Mapping.java @@ -156,11 +156,11 @@ public class BasicPartition2Mapping extends AbstractPartition2Mapping assert targetCost != null; for (@NonNull Edge edge : QVTscheduleUtil.getIncomingEdges(targetNode)) { Role edgeRole = partition.getRole(edge); - if ((edgeRole != null) && edgeRole.isOld() && edge.isUnconditional()) { + if ((edgeRole != null) && edgeRole.isOld() && !edge.isConditional()) { Node sourceNode = QVTscheduleUtil.getSourceNode(edge); Integer sourceCost = reachabilityForest.getCost(sourceNode); assert sourceCost != null; - if (sourceCost < targetCost) { + if (sourceCost < targetCost) { // Is targetCost <= sourceCost possible ? ?? an assert error addEdge(edge); } } @@ -275,13 +275,13 @@ public class BasicPartition2Mapping extends AbstractPartition2Mapping public void synthesize(@NonNull Iterable<@NonNull CheckedCondition> checkedConditions) { for (@NonNull Edge edge : edgeSchedule) { assert partition.getRole(edge) != null;; - assert edge.isUnconditional(); + assert !edge.isConditional(); Node sourceNode = QVTscheduleUtil.getSourceNode(edge); - assert sourceNode.isUnconditional(); + assert !sourceNode.isConditional(); Role sourceNodeRole = partition.getRole(sourceNode); if (sourceNodeRole != null) { Node targetNode = QVTscheduleUtil.getTargetNode(edge); - assert targetNode.isUnconditional(); + assert !targetNode.isConditional(); Role targetNodeRole = partition.getRole(targetNode); if (targetNodeRole != null) { if (edge.isNavigation()) { @@ -578,7 +578,7 @@ public class BasicPartition2Mapping extends AbstractPartition2Mapping private @NonNull DeclareStatement createDeclareStatement(@NonNull Node node, @NonNull OCLExpression initExpression) { Type variableType = node.getClassDatum().getPrimaryClass(); assert variableType != null; - boolean isRequired = node.isMatched() && node.isRequired(); + boolean isRequired = !node.isConditional() && node.isRequired(); if (initExpression.isIsRequired()) { isRequired = true; } @@ -789,7 +789,7 @@ public class BasicPartition2Mapping extends AbstractPartition2Mapping } else { assert !isPartial; - assert !isNotify; + // assert !isNotify; NewStatement newStatement = (NewStatement)asVariable; NewStatementPart newStatementPart = helper.createNewStatementPart(property, valueExp); newStatement.getOwnedParts().add(newStatementPart); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/AbstractRegionAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/AbstractRegionAnalysis.java index 8747426c4..d93afda4e 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/AbstractRegionAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/AbstractRegionAnalysis.java @@ -108,8 +108,6 @@ public abstract class AbstractRegionAnalysis extends AbstractPartialRegionAnalys /* if (!(region instanceof DispatchRegion) && !(region instanceof VerdictRegion)) { RegionHelper<@NonNull MappingRegion> regionHelper = new RegionHelper<>(scheduleManager, (MappingRegion)region); successEdge = regionHelper.createRealizedSuccess(traceNode, successProperty, null); // FIXME This creates a premature success in a speculation - Node successNode = QVTscheduleUtil.getTargetNode(successEdge); - successNode.setUtility(Node.Utility.STRONGLY_MATCHED); // FIXME is this really neded } */ } } @@ -132,8 +130,6 @@ public abstract class AbstractRegionAnalysis extends AbstractPartialRegionAnalys /* if (!(region instanceof DispatchRegion) && !(region instanceof VerdictRegion)) { RegionHelper<@NonNull MappingRegion> regionHelper = new RegionHelper<>(scheduleManager, (MappingRegion)region); successEdge = regionHelper.createRealizedSuccess(traceNode, successProperty, null); // FIXME This creates a premature success in a speculation - Node successNode = QVTscheduleUtil.getTargetNode(successEdge); - successNode.setUtility(Node.Utility.STRONGLY_MATCHED); // FIXME is this really neded } */ } } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/QVTs2QVTs.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/QVTs2QVTs.java index 2a59255de..79915cf41 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/QVTs2QVTs.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/QVTs2QVTs.java @@ -30,7 +30,6 @@ import org.eclipse.qvtd.compiler.ProblemHandler; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.ConnectivityChecker; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.LoadingRegionAnalysis; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.ScheduleManager; -import org.eclipse.qvtd.compiler.internal.qvtb2qvts.UtilityAnalysis; import org.eclipse.qvtd.compiler.internal.common.TypedModelsConfiguration; import org.eclipse.qvtd.compiler.internal.qvtb2qvts.AbstractTransformationAnalysis; import org.eclipse.qvtd.compiler.internal.qvtm2qvts.QVTm2QVTs; @@ -626,7 +625,6 @@ public class QVTs2QVTs extends QVTimperativeHelper if (s != null) { QVTscheduleConstants.CONNECTION_CREATION.println(s.toString());; } - UtilityAnalysis.assignUtilities(directedScheduleManager, loadingRegion); directedScheduleManager.writeDebugGraphs("4-pre-partition", rootRegion, true, true, false); directedScheduleManager.throwCompilerChainExceptionForErrors(); // diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/RegionAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/RegionAnalysis.java index b0187e6ce..23433339d 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/RegionAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/RegionAnalysis.java @@ -32,8 +32,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.NavigationEdge; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.Region; import org.eclipse.qvtd.pivot.qvtschedule.RuleRegion; -import org.eclipse.qvtd.pivot.qvtschedule.SuccessEdge; -import org.eclipse.qvtd.pivot.qvtschedule.Node.Utility; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; public class RegionAnalysis extends AbstractRegionAnalysis @@ -109,8 +108,7 @@ public class RegionAnalysis extends AbstractRegionAnalysis Relation2TraceClass relation2TraceClass = relation2traceGroup.getRule2TraceClass(); Element2MiddleProperty relation2localSuccessProperty = relation2TraceClass.getRelation2LocalSuccessProperty(); Property localSuccessProperty = relation2localSuccessProperty.getTraceProperty(); - SuccessEdge localSuccessEdge = relationAnalysis.createRealizedSuccess(traceNode, localSuccessProperty, null); - QVTscheduleUtil.getTargetNode(localSuccessEdge).setUtility(Utility.STRONGLY_MATCHED); + relationAnalysis.createRealizedSuccess(InitUtility.NON_NULL_MATCHED, traceNode, localSuccessProperty, null); analyzeLocalSuccessEdge(traceNode); } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/analysis/AbstractPartialRegionAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/analysis/AbstractPartialRegionAnalysis.java index ccf692804..0e8f74a23 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/analysis/AbstractPartialRegionAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/analysis/AbstractPartialRegionAnalysis.java @@ -289,7 +289,7 @@ public abstract class AbstractPartialRegionAnalysis<@NonNull PRA extends Partial else { oldPrimaryNavigableEdges.add(navigationEdge); } - if (!isRealized(navigationEdge) && navigationEdge.isMatched()) { // FIXME is this totally obsolete + if (!isRealized(navigationEdge) && !navigationEdge.isConditional()) { // FIXME is this totally obsolete assert !navigationEdge.isExpression(); assert !navigationEdge.isComputation(); } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/checks/CheckedConditionAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/checks/CheckedConditionAnalysis.java index 638590757..72d568102 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/checks/CheckedConditionAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/checks/CheckedConditionAnalysis.java @@ -85,7 +85,7 @@ public class CheckedConditionAnalysis } for (@NonNull Node node : partition.getPartialNodes()) { Role nodeRole = partition.getRole(node); - if ((nodeRole != null) && nodeRole.isOld() && node.isUnconditional()) { + if ((nodeRole != null) && nodeRole.isOld() && !node.isConditional() && !node.isDependency()) { node.accept(this); } } @@ -387,7 +387,7 @@ public class CheckedConditionAnalysis List<@NonNull Edge> oldEdges = new ArrayList<>(); for (@NonNull Edge edge : partition.getPartialEdges()) { Role edgeRole = partition.getRole(edge); - if ((edgeRole != null) && edgeRole.isOld() && edge.isUnconditional()) { + if ((edgeRole != null) && edgeRole.isOld() && !edge.isConditional()) { Node sourceNode = QVTscheduleUtil.getSourceNode(edge); Role sourceNodeRole = partition.getRole(sourceNode); if ((sourceNodeRole != null) && sourceNodeRole.isOld()) { diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/EdgeMerger.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/EdgeMerger.java index a82627ffa..fdb61731e 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/EdgeMerger.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/EdgeMerger.java @@ -60,7 +60,7 @@ class EdgeMerger Edge mergedEdge2 = mergedEdge; assert mergedEdge2 == null; for (@NonNull Edge originalEdge : originalEdges) { - mergedEdge2 = mergedEdge = originalEdge.createEdge(edgeRole, sourceNodeMerger, targetNodeMerger); + mergedEdge2 = mergedEdge = originalEdge.createEdge(edgeRole, originalEdge.getInitUtility(), sourceNodeMerger, targetNodeMerger); break; } if (mergedEdge2 == null) { @@ -139,9 +139,9 @@ class EdgeMerger return getPrimaryEdge().isOld(); // FIXME check all original edges } - public boolean isUnconditional() { - return getPrimaryEdge().isUnconditional(); // FIXME check all original edges - } + // public boolean isUnconditional() { + // return getPrimaryEdge().isUnconditional(); // FIXME check all original edges + // } /** * Return an originalEdge that is the same as mergedEdge or null if none. diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/NodeMerger.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/NodeMerger.java index d6d4f7753..19112d2b8 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/NodeMerger.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/NodeMerger.java @@ -35,7 +35,7 @@ class NodeMerger protected final @NonNull RegionMerger regionMerger; protected final @NonNull List<@NonNull Node> originalNodes = new ArrayList<>(); private @NonNull Role nodeRole; - private Node.@NonNull Utility nodeUtility; + // private Node.@NonNull Utility nodeUtility; private @NonNull Map<@NonNull NodeMerger, @NonNull List<@NonNull EdgeMerger>> sourceNodeMerger2edgeMergers = new HashMap<>(); private @NonNull Map<@NonNull NodeMerger, @NonNull List<@NonNull EdgeMerger>> targetNodeMerger2edgeMergers = new HashMap<>(); private @Nullable Node mergedNode = null; @@ -44,7 +44,7 @@ class NodeMerger this.regionMerger = regionMerger; originalNodes.add(originalNode); nodeRole = QVTscheduleUtil.getNodeRole(originalNode); - nodeUtility = originalNode.getUtility(); + // nodeUtility = originalNode.getUtility(); regionMerger.mapOriginalNode(originalNode, this); } @@ -64,7 +64,7 @@ class NodeMerger assert !originalNodes.contains(originalNode); originalNodes.add(originalNode); nodeRole = QVTscheduleUtil.mergeToMoreKnownPhase(nodeRole, QVTscheduleUtil.getNodeRole(originalNode)); - nodeUtility = QVTscheduleUtil.mergeToStrongerUtility(nodeUtility, originalNode.getUtility()); + // nodeUtility = QVTscheduleUtil.mergeToStrongerUtility(nodeUtility, originalNode.getUtility()); regionMerger.mapOriginalNode(originalNode, this); } @@ -77,7 +77,6 @@ class NodeMerger mergedNode2.setHead(); mergedRegion.getHeadNodes().add(mergedNode2); } - mergedNode2.setUtility(nodeUtility); break; } if (mergedNode2 == null) { @@ -174,6 +173,10 @@ class NodeMerger return originalNodes.get(0); } + // public boolean isConditional() { + // return getPrimaryNode().isConditional(); // FIXME check all original nodes + // } + public boolean isConstant() { return getPrimaryNode().isConstant(); // FIXME check all original nodes } @@ -202,10 +205,6 @@ class NodeMerger return getPrimaryNode().isRequired(); // FIXME check all original nodes } - public boolean isUnconditional() { - return getPrimaryNode().isUnconditional(); // FIXME check all original nodes - } - public void removeIncomingEdgeMerger(@NonNull EdgeMerger edgeMerger, @NonNull NodeMerger sourceNodeMerger) { List<@NonNull EdgeMerger> edgeMergers = getIncomingEdgeMergers(sourceNodeMerger); boolean wasRemoved = edgeMergers.remove(edgeMerger); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/GlobalPredicatePartitionFactory.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/GlobalPredicatePartitionFactory.java index 60147ba82..551429524 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/GlobalPredicatePartitionFactory.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/GlobalPredicatePartitionFactory.java @@ -257,7 +257,7 @@ public class GlobalPredicatePartitionFactory extends AbstractSimplePartitionFact protected void resolvePredicatedMiddleNodes(@NonNull BasicPartition partition) { for (@NonNull Node node : mappingPartitioner.getPredicatedMiddleNodes()) { - if (!partition.hasNode(node) && node.isMatched()) { // && mappingPartitioner.isCyclic(node)) { + if (!partition.hasNode(node) && !node.isConditional()) { // && mappingPartitioner.isCyclic(node)) { Role nodeRole = QVTscheduleUtil.getNodeRole(node); // if (node.isPattern() && node.isClass()) { // nodeRole = QVTscheduleUtil.asSpeculated(nodeRole); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/LocalPredicatePartitionFactory.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/LocalPredicatePartitionFactory.java index 7f50837cf..e97d280f1 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/LocalPredicatePartitionFactory.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/LocalPredicatePartitionFactory.java @@ -24,8 +24,8 @@ import org.eclipse.qvtd.compiler.internal.qvts2qvts.utilities.ReachabilityForest import org.eclipse.qvtd.pivot.qvtschedule.BasicPartition; import org.eclipse.qvtd.pivot.qvtschedule.Edge; import org.eclipse.qvtd.pivot.qvtschedule.Node; -import org.eclipse.qvtd.pivot.qvtschedule.Node.Utility; import org.eclipse.qvtd.pivot.qvtschedule.Role; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; import com.google.common.collect.Iterables; @@ -182,8 +182,8 @@ public class LocalPredicatePartitionFactory extends AbstractSimplePartitionFacto // boolean isPredicated = node.isPredicated(); // boolean isMatched = node.isMatched(); // boolean isUnconditional = node.isUnconditional(); - Utility utility = node.getUtility(); - boolean isWeaklyMatched = utility == Utility.WEAKLY_MATCHED; + InitUtility initUtility = node.getInitUtility(); + boolean isWeaklyMatched = initUtility == InitUtility.NULLABLE_MATCHED; // Utility.WEAKLY_MATCHED; boolean isTraced = isTraced(node, executionNodes); if (!isCyclicCorollary && (isTraced || isWeaklyMatched)) { addNode(partition, node); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculatedPartitionFactory.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculatedPartitionFactory.java index 16ceac222..898a30bd5 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculatedPartitionFactory.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculatedPartitionFactory.java @@ -181,7 +181,7 @@ public class SpeculatedPartitionFactory extends AbstractSimplePartitionFactory }*/ protected void resolveTraceNodes(@NonNull BasicPartition partition, @NonNull Node traceNode) { - assert traceNode.isMatched() && traceNode.isClass() && traceNode.isPattern(); + assert !traceNode.isConditional() && traceNode.isClass() && traceNode.isPattern(); addNode(partition, traceNode, Role.PREDICATED); if (scheduleManager.useActivators()) { Node localSuccessNode = mappingPartitioner.basicGetLocalSuccessNode(traceNode); diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/CompoundGroup.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/CompoundGroup.java index 9bd0c82e4..eb8c5b664 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/CompoundGroup.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/CompoundGroup.java @@ -195,7 +195,7 @@ class CompoundGroup extends AbstractGroup if (edge.isNavigation()) { NavigationEdge navigationEdge = (NavigationEdge)edge; assert edge.getEdgeSource() == nonOverlapNode; - if (!edge.isRealized() && edge.isMatched()) { + if (!edge.isRealized() && edge.isUnconditional()) { Property property = QVTscheduleUtil.getReferredProperty(navigationEdge); Property opposite = property.getOpposite(); if ((opposite != null) && opposite.isIsMany()) { diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/SplitterAnalysis.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/SplitterAnalysis.java index 173756b51..a546ce625 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/SplitterAnalysis.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/SplitterAnalysis.java @@ -52,7 +52,7 @@ class SplitterAnalysis // List<@NonNull Node> headNodes = new ArrayList<>(); for (@NonNull Node headNode : QVTscheduleUtil.getHeadNodes(region)) { - if (headNode.isMatched()) { // Ignore extra heads + if (!headNode.isConditional()) { // Ignore extra heads headNodes.add(headNode); } } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/SplitterUtil.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/SplitterUtil.java index cba2bcd15..5719fd720 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/SplitterUtil.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/splitter/SplitterUtil.java @@ -62,7 +62,7 @@ class SplitterUtil if (computableTargetNodes.add(sourceNode)) { for (@NonNull Edge edge : QVTscheduleUtil.getOutgoingEdges(sourceNode)) { assert !edge.isCast(); - if (edge.isComputation() || (edge.isNavigation() && !edge.isMatched())) { + if (edge.isComputation() || (edge.isNavigation() && !edge.isUnconditional())) { Node targetNode = edge.getEdgeTarget(); if (targetNode.isRealized() && targetNode.isOperation()) { unresolvedOperationNodes.add(targetNode); // Keys require an all-input check. @@ -127,7 +127,7 @@ class SplitterUtil assert edge.getEdgeSource() == sourceNode; if (edge instanceof NavigationEdge) { NavigationEdge navigationEdge = (NavigationEdge) edge; - if (!navigationEdge.isRealized() && navigationEdge.isMatched()) { + if (!navigationEdge.isRealized() && navigationEdge.isUnconditional()) { Node targetNode = navigationEdge.getEdgeTarget(); computeNavigableNodes(reachableNodes, targetNode); } diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/utilities/ReachabilityForest.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/utilities/ReachabilityForest.java index 493cabcc9..ba020ddfd 100644 --- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/utilities/ReachabilityForest.java +++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/utilities/ReachabilityForest.java @@ -145,7 +145,7 @@ public class ReachabilityForest NavigationEdge oppositeEdge = navigationEdge.getOppositeEdge(); if (forwardEdges.contains(oppositeEdge)) { boolean isImplicit = QVTscheduleUtil.getReferredProperty(oppositeEdge).isIsImplicit(); - int nextCost = thisCost + (isImplicit ? INVERSE_NAVIGATION_COST : FORWARD_NAVIGATION_COST); + int nextCost = thisCost + (isImplicit ? INVERSE_NAVIGATION_COST : FORWARD_NAVIGATION_COST); // FIXME FORWARD_NAVIGATION_COST used for some actual opposites if ((targetCost == null) || (nextCost < targetCost)) { node2cost.put(targetNode, nextCost); node2reachingEdge.put(targetNode, oppositeEdge); diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/CastEdge.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/CastEdge.java index f1f66ae7d..bb5fcfdcb 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/CastEdge.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/CastEdge.java @@ -15,6 +15,7 @@ package org.eclipse.qvtd.pivot.qvtschedule; import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -65,5 +66,5 @@ public interface CastEdge extends Edge */ void setReferredClassDatum(ClassDatum value); - void initialize(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull ClassDatum classDatum, @NonNull Node targetNode); + void initialize(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull ClassDatum classDatum, @NonNull Node targetNode); } // CastEdge diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/Edge.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/Edge.java index ff962b823..23dffb554 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/Edge.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/Edge.java @@ -18,6 +18,7 @@ import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.eclipse.ocl.pivot.Element; import org.eclipse.qvtd.pivot.qvtbase.graphs.GraphStringBuilder.GraphEdge; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -218,7 +219,7 @@ public interface Edge extends Element, org.eclipse.ocl.pivot.utilities.Nameable, /** * Create an edgeRole edge from sourceNode to targetNode with the same name as this edge. */ - @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode); + @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility initUtility, @NonNull Node sourceNode, @NonNull Node targetNode); void destroy(); @@ -262,7 +263,7 @@ public interface Edge extends Element, org.eclipse.ocl.pivot.utilities.Nameable, */ @Nullable String getLabel(); - void initialize(@NonNull Role edgeRole, @NonNull Node sourceNode, @Nullable String name, @NonNull Node targetNode); + void initialize(@NonNull Role edgeRole, @NonNull InitUtility initUtility, @NonNull Node sourceNode, @Nullable String name, @NonNull Node targetNode); /** * Return true if this edge is for an oclAsType cast. @@ -280,6 +281,11 @@ public interface Edge extends Element, org.eclipse.ocl.pivot.utilities.Nameable, boolean isComputation(); /** + * Return true is this edge is a conditional part of a pattern. + */ + boolean isConditional(); + + /** * Return true if this edge conveys a compile-time constant. */ boolean isConstant(); @@ -301,15 +307,6 @@ public interface Edge extends Element, org.eclipse.ocl.pivot.utilities.Nameable, boolean isLoaded(); /** - * Return true if after execution this edge exactly corresponds to a relationship between its matching ends. - * Conversely return false if this edge is a conditional execution path or its ends my be optional nulls. - * Collections are never null-valued, not even empty collections. - * - * *deprecated try to use isUnconditional or getUtility - */ - boolean isMatched(); - - /** * Return true if this edge is for a speculation/realized relationship. */ boolean isNew(); @@ -370,12 +367,15 @@ public interface Edge extends Element, org.eclipse.ocl.pivot.utilities.Nameable, boolean isSuccess(); /** - * Return true is this edge is used as part of an unconditional navigation or computation. - * i.e. it is not part of a loop or dependent upon if conditions. + * Return true if after execution this edge exactly corresponds to a relationship between its matching ends. + * Conversely return false if this edge is a conditional execution path or its ends my be optional nulls. + * Collections are never null-valued, not even empty collections. */ boolean isUnconditional(); void setSource(@NonNull Node sourceNode); void setTarget(@NonNull Node targetNode); + + @NonNull InitUtility getInitUtility(); } // Edge diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/MappingNode.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/MappingNode.java index 4da63cd13..44a4660ef 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/MappingNode.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/MappingNode.java @@ -58,7 +58,6 @@ public interface MappingNode extends Node { * @model default="false" required="true" * @generated */ - @Override boolean isMatched(); /** diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/NavigationEdge.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/NavigationEdge.java index cd76b43a5..931849489 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/NavigationEdge.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/NavigationEdge.java @@ -16,6 +16,7 @@ package org.eclipse.qvtd.pivot.qvtschedule; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.Property; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -146,5 +147,5 @@ public interface NavigationEdge extends NavigableEdge { */ void setSecondary(boolean value); - void initializeProperty(@NonNull Property property, boolean isPartial); + void initializeProperty(@NonNull Property property, @NonNull InitUtility utility, boolean isPartial); } // NavigationEdge diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/Node.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/Node.java index 2c5c1865c..c8e31050b 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/Node.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/Node.java @@ -22,6 +22,7 @@ import org.eclipse.ocl.pivot.Element; import org.eclipse.ocl.pivot.Property; import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.qvtd.pivot.qvtbase.graphs.GraphStringBuilder.GraphNode; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -248,7 +249,7 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util /** * The prioritized immutable utility of each node. * - * FIXME Change STRONGLY_MATCHED/WEAKLY_MATCHED to EXACTLY_ONE_MATCH/ZEROO_OR_ONE_MATCH/ONE_OR_MANY_MATCHES/SOME_OR_MANY__MATCH + * FIXME Change STRONGLY_MATCHED/WEAKLY_MATCHED to EXACTLY_ONE_MATCH/ZERO_OR_ONE_MATCH/ONE_OR_MANY_MATCHES/SOME_OR_MANY__MATCH * so that the optionality of Node.isMatched() is redundnt wrt getUtility().isXXXX. */ public enum Utility { @@ -256,10 +257,10 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util DISPATCH, /** The predicated/realized trace node.*/ TRACE, - /** Reachable by to-1 navigation from a head node, or by to-? to an ExplicitNull.*/ + /** Reachable by to-1 navigation from the (?? a) trace node, or by to-? to an ExplicitNull.*/ STRONGLY_MATCHED, /** Unconditionally used in a computation or navigation, but not a dispatcher/trace node, - * not reachable by to-1 navigation from a head node, not an ExplicitNull reachable by to-?.*/ + * not reachable by to-1 navigation from the (?? a) trace node, not an ExplicitNull reachable by to-?.*/ WEAKLY_MATCHED, // UNCONDITIONALLY_PREDICATING, // else always computable as part of a predicate // CONDITIONALLY_PREDICATING, // else selectively computable as part of a predicate depending on if conditions @@ -271,7 +272,7 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util /** A LoadingRegion element.*/ COMPOSED, /** Never used */ - DEAD; + DEAD } /** @@ -290,7 +291,6 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util * Return a variable that shares the value of the element from which this node originated. May be null. */ @Nullable VariableDeclaration basicGetOriginatingVariable(); - @Nullable Utility basicGetUtility(); /** * Create a new nodeRole node in region with the saem name, type etc as this node. @@ -363,9 +363,9 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util // @NonNull Iterable<@NonNull Node> getUsedBindingSources(); @Nullable String getShape(); @Nullable String getStyle(); - @NonNull Utility getUtility(); + // @NonNull Utility getUtility(); - void initialize(@NonNull Role nodeRole, @NonNull Region region, /*@NonNull*/ String name, /*@NonNull*/ ClassDatum classDatum); + void initialize(@NonNull Role nodeRole, @NonNull Region region, @NonNull InitUtility utility, /*@NonNull*/ String name, /*@NonNull*/ ClassDatum classDatum); /** * Return true if this node is checked; i.e. isPredicated() or isSpeculated(). @@ -380,6 +380,11 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util boolean isComposed(); /** + * Return true if this node is a conditional part of a pattern. + */ + boolean isConditional(); + + /** * Return true if this node is a constant that can be computed at compile time. * * isConstant() is exclusive to isLoaded()/isSpeculation()/isSpeculated()/isPredicated()/isRealized() @@ -439,15 +444,6 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util boolean isLoaded(); /** - * Return true if after execution this node exactly corresponds to a non-null object or to a non-null value or to an explicit null. - * Conversely return false if this node is optionally null or part of a conditional expression evaluation. - * Collections are never null-valued, not even empty collections. - * - * *deprecated try to use isUnconditional or getUtility - */ - boolean isMatched(); - - /** * Return true if this node is for a speculation/realized element. */ boolean isNew(); @@ -535,8 +531,7 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util // boolean isTrue(); /** - * Return true if this node is unconditionally used in a computation of navigation. i.e it does not form - * part of a loop or a then/else arm. + * Return true if this node is an unconditional part of a pattern. */ boolean isUnconditional(); @@ -560,11 +555,6 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util void setOriginatingVariable(@NonNull VariableDeclaration variable); /** - * Register variable as non-null. - */ - void setRequired(); - - /** * Set isStrict true if this node is the realized node for a unique mapping invocation. */ void setStrict(boolean isStrict); @@ -574,5 +564,5 @@ public interface Node extends Element, ConnectionEnd, org.eclipse.ocl.pivot.util */ void setThis(); - void setUtility(@NonNull Utility utility); + @NonNull InitUtility getInitUtility(); } // Node diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/BooleanLiteralNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/BooleanLiteralNodeImpl.java index 692cd3d1d..9fc9d496d 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/BooleanLiteralNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/BooleanLiteralNodeImpl.java @@ -24,7 +24,6 @@ import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.eclipse.ocl.pivot.internal.ElementImpl; import org.eclipse.ocl.pivot.util.Visitor; - import org.eclipse.qvtd.pivot.qvtschedule.BooleanLiteralNode; import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.NodeConnection; @@ -32,7 +31,6 @@ import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Region; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; -import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; /** * <!-- begin-user-doc --> @@ -152,7 +150,7 @@ public class BooleanLiteralNodeImpl extends OperationNodeImpl implements Boolean switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setBooleanValue((Boolean)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -167,7 +165,7 @@ public class BooleanLiteralNodeImpl extends OperationNodeImpl implements Boolean switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setBooleanValue(BOOLEAN_VALUE_EDEFAULT); - return; + return; } super.eUnset(featureID); } @@ -215,11 +213,6 @@ public class BooleanLiteralNodeImpl extends OperationNodeImpl implements Boolean } @Override - public @Nullable String getStyle() { - return "rounded"; - } - - @Override public boolean isPrimitive() { return true; } @@ -231,12 +224,6 @@ public class BooleanLiteralNodeImpl extends OperationNodeImpl implements Boolean } @Override - public void setUtility(@NonNull Utility utility) { - assert QVTscheduleUtil.isUnconditional(utility); - super.setUtility(utility); - } - - @Override public void setNodeRole(Role newNodeRole) { assert newNodeRole == Role.CONSTANT; super.setNodeRole(newNodeRole); diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/CastEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/CastEdgeImpl.java index 8d37eec59..f9229b091 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/CastEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/CastEdgeImpl.java @@ -28,6 +28,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -138,7 +139,7 @@ public class CastEdgeImpl extends EdgeImpl implements CastEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: if (resolve) return getReferredClassDatum(); - return basicGetReferredClassDatum(); + return basicGetReferredClassDatum(); } return super.eGet(featureID, resolve, coreType); } @@ -153,7 +154,7 @@ public class CastEdgeImpl extends EdgeImpl implements CastEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredClassDatum((ClassDatum)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -168,7 +169,7 @@ public class CastEdgeImpl extends EdgeImpl implements CastEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredClassDatum((ClassDatum)null); - return; + return; } super.eUnset(featureID); } @@ -208,8 +209,8 @@ public class CastEdgeImpl extends EdgeImpl implements CastEdge { } @Override - public void initialize(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull ClassDatum classDatum, @NonNull Node targetNode) { - super.initialize(edgeRole, sourceNode, classDatum.getName(), targetNode); + public void initialize(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull ClassDatum classDatum, @NonNull Node targetNode) { + super.initialize(edgeRole, utility, sourceNode, classDatum.getName(), targetNode); setReferredClassDatum(classDatum); } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/CollectionPartEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/CollectionPartEdgeImpl.java index 0793810cf..179078b21 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/CollectionPartEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/CollectionPartEdgeImpl.java @@ -33,6 +33,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -142,7 +143,7 @@ public class CollectionPartEdgeImpl extends ArgumentEdgeImpl implements Collecti switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: if (resolve) return getReferredPart(); - return basicGetReferredPart(); + return basicGetReferredPart(); } return super.eGet(featureID, resolve, coreType); } @@ -157,7 +158,7 @@ public class CollectionPartEdgeImpl extends ArgumentEdgeImpl implements Collecti switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((CollectionLiteralPart)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -172,7 +173,7 @@ public class CollectionPartEdgeImpl extends ArgumentEdgeImpl implements Collecti switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((CollectionLiteralPart)null); - return; + return; } super.eUnset(featureID); } @@ -207,8 +208,8 @@ public class CollectionPartEdgeImpl extends ArgumentEdgeImpl implements Collecti } @Override - public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { - CollectionPartEdge newEdge = (CollectionPartEdge) super.createEdge(edgeRole, sourceNode, targetNode); + public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { + CollectionPartEdge newEdge = (CollectionPartEdge) super.createEdge(edgeRole, utility, sourceNode, targetNode); newEdge.setReferredPart(getReferredPart()); return newEdge; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/ComposedNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/ComposedNodeImpl.java index aa05f177b..f00259c9b 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/ComposedNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/ComposedNodeImpl.java @@ -86,9 +86,4 @@ public class ComposedNodeImpl extends NodeImpl implements ComposedNode { public boolean isComposed() { return true; } - - @Override - public boolean isMatched() { - return true; - } } //ComposedNodeImpl diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/DependencyNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/DependencyNodeImpl.java index 36a7a95b8..9d8190fa0 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/DependencyNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/DependencyNodeImpl.java @@ -19,9 +19,13 @@ import org.eclipse.emf.ecore.EClass; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.util.Visitor; +import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; import org.eclipse.qvtd.pivot.qvtschedule.DependencyNode; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; +import org.eclipse.qvtd.pivot.qvtschedule.Region; +import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -86,4 +90,12 @@ public class DependencyNodeImpl extends NodeImpl implements DependencyNode { public boolean isDependency() { return true; } + + @Override + public void initialize(@NonNull Role nodeRole, @NonNull Region region, + @NonNull InitUtility initUtility, String name, + ClassDatum classDatum) { + // TODO Auto-generated method stub + super.initialize(nodeRole, region, initUtility, name, classDatum); + } } //DependencyNodeImpl diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/EdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/EdgeImpl.java index 4746fb553..e252f075c 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/EdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/EdgeImpl.java @@ -33,6 +33,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.QVTscheduleFactory; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Region; import org.eclipse.qvtd.pivot.qvtschedule.Role; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleConstants; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; @@ -448,19 +449,19 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { case ElementImpl.ELEMENT_FEATURE_COUNT + 0: if (cluster != null) msgs = ((InternalEObject)cluster).eInverseRemove(this, NamedElementImpl.NAMED_ELEMENT_FEATURE_COUNT + 3, Cluster.class, msgs); - return basicSetCluster((Cluster)otherEnd, msgs); + return basicSetCluster((Cluster)otherEnd, msgs); case ElementImpl.ELEMENT_FEATURE_COUNT + 3: if (eInternalContainer() != null) msgs = eBasicRemoveFromContainer(msgs); - return basicSetOwningRegion((Region)otherEnd, msgs); + return basicSetOwningRegion((Region)otherEnd, msgs); case ElementImpl.ELEMENT_FEATURE_COUNT + 4: if (sourceNode != null) msgs = ((InternalEObject)sourceNode).eInverseRemove(this, ElementImpl.ELEMENT_FEATURE_COUNT + 7, Node.class, msgs); - return basicSetSourceNode((Node)otherEnd, msgs); + return basicSetSourceNode((Node)otherEnd, msgs); case ElementImpl.ELEMENT_FEATURE_COUNT + 5: if (targetNode != null) msgs = ((InternalEObject)targetNode).eInverseRemove(this, ElementImpl.ELEMENT_FEATURE_COUNT + 3, Node.class, msgs); - return basicSetTargetNode((Node)otherEnd, msgs); + return basicSetTargetNode((Node)otherEnd, msgs); } return super.eInverseAdd(otherEnd, featureID, msgs); } @@ -509,7 +510,7 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 0: if (resolve) return getCluster(); - return basicGetCluster(); + return basicGetCluster(); case ElementImpl.ELEMENT_FEATURE_COUNT + 1: return getEdgeRole(); case ElementImpl.ELEMENT_FEATURE_COUNT + 2: @@ -518,10 +519,10 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { return getOwningRegion(); case ElementImpl.ELEMENT_FEATURE_COUNT + 4: if (resolve) return getSourceNode(); - return basicGetSourceNode(); + return basicGetSourceNode(); case ElementImpl.ELEMENT_FEATURE_COUNT + 5: if (resolve) return getTargetNode(); - return basicGetTargetNode(); + return basicGetTargetNode(); } return super.eGet(featureID, resolve, coreType); } @@ -536,22 +537,22 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 0: setCluster((Cluster)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 1: setEdgeRole((Role)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 2: setName((String)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 3: setOwningRegion((Region)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 4: setSourceNode((Node)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 5: setTargetNode((Node)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -566,22 +567,22 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 0: setCluster((Cluster)null); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 1: setEdgeRole(EDGE_ROLE_EDEFAULT); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 2: setName(NAME_EDEFAULT); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 3: setOwningRegion((Region)null); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 4: setSourceNode((Node)null); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 5: setTargetNode((Node)null); - return; + return; } super.eUnset(featureID); } @@ -671,9 +672,9 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { } @Override - public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { + public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { EdgeImpl edge = (EdgeImpl)QVTscheduleFactory.eINSTANCE.create(eClass()); - edge.initialize(edgeRole, sourceNode, name, targetNode); + edge.initialize(edgeRole, utility, sourceNode, name, targetNode); return edge; } @@ -715,7 +716,15 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { @Override public @NonNull String getColor() { assert edgeRole != null; - return QVTscheduleUtil.getColor(edgeRole); + switch (initUtility) { + case NON_NULL_CONDITIONAL: + case NON_NULL_MATCHED: + case NULLABLE_CONDITIONAL: + case NULLABLE_MATCHED: + return QVTscheduleUtil.getColor(edgeRole); + default: + return QVTscheduleUtil.ERROR_COLOR; + } } @Override @@ -739,20 +748,47 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { } public @NonNull Integer getPenwidth() { - return (isCast() || isNavigation()) ? 2*QVTscheduleConstants.LINE_WIDTH : QVTscheduleConstants.LINE_WIDTH; + switch (initUtility) { + case NULLABLE_MATCHED: + case NON_NULL_MATCHED: + return 2*QVTscheduleConstants.LINE_WIDTH; + case NON_NULL_CONDITIONAL: + case NULLABLE_CONDITIONAL: + return 1*QVTscheduleConstants.LINE_WIDTH; + default: + return 4*QVTscheduleConstants.LINE_WIDTH; + } + // return (isCast() || isNavigation()) ? 2*QVTscheduleConstants.LINE_WIDTH : QVTscheduleConstants.LINE_WIDTH; } public @Nullable String getStyle() { - return isMatched() ? null : "dashed"; + switch (initUtility) { + case NON_NULL_CONDITIONAL: + case NON_NULL_MATCHED: + return null; + case NULLABLE_CONDITIONAL: + case NULLABLE_MATCHED: + return "dashed"; + default: + return "dotted"; + } + } + + private @NonNull InitUtility initUtility = InitUtility.NOT_KNOWN; + + @Override + public @NonNull InitUtility getInitUtility() { + return initUtility; } @Override - public void initialize(@NonNull Role edgeRole, @NonNull Node sourceNode, @Nullable String name, @NonNull Node targetNode) { + public void initialize(@NonNull Role edgeRole, @NonNull InitUtility initUtility, @NonNull Node sourceNode, @Nullable String name, @NonNull Node targetNode) { setOwningRegion(QVTscheduleUtil.getOwningRegion(sourceNode)); setEdgeRole(edgeRole); setName(name); setSource(sourceNode); setTarget(targetNode); + this.initUtility = initUtility; } @Override @@ -772,6 +808,11 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { } @Override + public boolean isConditional() { + return initUtility.isConditional(); + } + + @Override public boolean isConstant() { assert edgeRole != null; return edgeRole == Role.CONSTANT; @@ -794,11 +835,6 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { } @Override - public final boolean isMatched() { - return QVTscheduleUtil.getSourceNode(this).isMatched() && QVTscheduleUtil.getTargetNode(this).isMatched(); - } - - @Override public boolean isNavigable() { return false; } @@ -864,8 +900,8 @@ public abstract class EdgeImpl extends ElementImpl implements Edge { } @Override - public boolean isUnconditional() { - return QVTscheduleUtil.getSourceNode(this).isUnconditional() && QVTscheduleUtil.getTargetNode(this).isUnconditional(); + public final boolean isUnconditional() { + return initUtility.isUnconditional(); } protected void mergeRole(@NonNull Role edgeRole) { diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/EnumLiteralNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/EnumLiteralNodeImpl.java index 622bea7c0..d8dc31ac6 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/EnumLiteralNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/EnumLiteralNodeImpl.java @@ -143,7 +143,7 @@ public class EnumLiteralNodeImpl extends OperationNodeImpl implements EnumLitera switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: if (resolve) return getEnumValue(); - return basicGetEnumValue(); + return basicGetEnumValue(); } return super.eGet(featureID, resolve, coreType); } @@ -158,7 +158,7 @@ public class EnumLiteralNodeImpl extends OperationNodeImpl implements EnumLitera switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setEnumValue((EnumerationLiteral)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -173,7 +173,7 @@ public class EnumLiteralNodeImpl extends OperationNodeImpl implements EnumLitera switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setEnumValue((EnumerationLiteral)null); - return; + return; } super.eUnset(featureID); } @@ -220,11 +220,6 @@ public class EnumLiteralNodeImpl extends OperationNodeImpl implements EnumLitera } @Override - public @Nullable String getStyle() { - return "rounded"; - } - - @Override public boolean isPrimitive() { return true; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/KeyPartEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/KeyPartEdgeImpl.java index 5a398b80f..d77c74003 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/KeyPartEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/KeyPartEdgeImpl.java @@ -32,6 +32,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.PropertyDatum; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -142,7 +143,7 @@ public class KeyPartEdgeImpl extends ArgumentEdgeImpl implements KeyPartEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: if (resolve) return getReferredPart(); - return basicGetReferredPart(); + return basicGetReferredPart(); } return super.eGet(featureID, resolve, coreType); } @@ -157,7 +158,7 @@ public class KeyPartEdgeImpl extends ArgumentEdgeImpl implements KeyPartEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((PropertyDatum)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -172,7 +173,7 @@ public class KeyPartEdgeImpl extends ArgumentEdgeImpl implements KeyPartEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((PropertyDatum)null); - return; + return; } super.eUnset(featureID); } @@ -207,8 +208,8 @@ public class KeyPartEdgeImpl extends ArgumentEdgeImpl implements KeyPartEdge { } @Override - public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { - KeyPartEdge newEdge = (KeyPartEdge) super.createEdge(edgeRole, sourceNode, targetNode); + public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { + KeyPartEdge newEdge = (KeyPartEdge) super.createEdge(edgeRole, utility, sourceNode, targetNode); newEdge.setReferredPart(getReferredPart()); return newEdge; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/MapPartEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/MapPartEdgeImpl.java index b8ed18ed8..75b497881 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/MapPartEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/MapPartEdgeImpl.java @@ -33,6 +33,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -143,7 +144,7 @@ public class MapPartEdgeImpl extends ArgumentEdgeImpl implements MapPartEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: if (resolve) return getReferredPart(); - return basicGetReferredPart(); + return basicGetReferredPart(); } return super.eGet(featureID, resolve, coreType); } @@ -158,7 +159,7 @@ public class MapPartEdgeImpl extends ArgumentEdgeImpl implements MapPartEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((MapLiteralPart)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -173,7 +174,7 @@ public class MapPartEdgeImpl extends ArgumentEdgeImpl implements MapPartEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((MapLiteralPart)null); - return; + return; } super.eUnset(featureID); } @@ -208,8 +209,8 @@ public class MapPartEdgeImpl extends ArgumentEdgeImpl implements MapPartEdge { } @Override - public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { - MapPartEdge newEdge = (MapPartEdge) super.createEdge(edgeRole, sourceNode, targetNode); + public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { + MapPartEdge newEdge = (MapPartEdge) super.createEdge(edgeRole, utility, sourceNode, targetNode); newEdge.setReferredPart(getReferredPart()); return newEdge; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/MappingNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/MappingNodeImpl.java index 89dcdb4bf..d9adfc35e 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/MappingNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/MappingNodeImpl.java @@ -25,7 +25,6 @@ import org.eclipse.emf.ecore.impl.ENotificationImpl; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.eclipse.ocl.pivot.Element; -import org.eclipse.ocl.pivot.TypedElement; import org.eclipse.ocl.pivot.Variable; import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.ocl.pivot.internal.ElementImpl; @@ -110,11 +109,12 @@ public abstract class MappingNodeImpl extends NodeImpl implements MappingNode { /** * <!-- begin-user-doc --> * <!-- end-user-doc --> - * @generated + * @generated NOT */ + @Deprecated /* @deprecated use initUtility */ @Override - public boolean isMatched() { - return matched; + public final boolean isMatched() { + return !getInitUtility().isConditional(); } /** @@ -154,7 +154,7 @@ public abstract class MappingNodeImpl extends NodeImpl implements MappingNode { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 9: setMatched((Boolean)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -169,7 +169,7 @@ public abstract class MappingNodeImpl extends NodeImpl implements MappingNode { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 9: setMatched(MATCHED_EDEFAULT); - return; + return; } super.eUnset(featureID); } @@ -188,7 +188,6 @@ public abstract class MappingNodeImpl extends NodeImpl implements MappingNode { return super.eIsSet(featureID); } - private boolean isRequired = true; private final @NonNull List<@NonNull Element> originatingElements = new ArrayList<>(); private @Nullable VariableDeclaration originatingVariable = null; @@ -197,7 +196,6 @@ public abstract class MappingNodeImpl extends NodeImpl implements MappingNode { assert getOwningRegion() != null; //instanceof MappingRegion; assert originatingElements.size() > 0; // Should have used setOriginatingElement assert !(originatingElement instanceof Variable); // Should have used setOriginatingVariable - assert isRequired == !(originatingElement instanceof TypedElement) || ((TypedElement)originatingElement).isIsRequired(); if (!originatingElements.contains(originatingElement)) { originatingElements.add(originatingElement); } @@ -216,12 +214,10 @@ public abstract class MappingNodeImpl extends NodeImpl implements MappingNode { @Override public @NonNull Node createNode(@NonNull Role nodeRole, @NonNull Region region) { MappingNodeImpl node = (MappingNodeImpl)super.createNode(nodeRole, region); - node.isRequired = isRequired; node.originatingVariable = originatingVariable; for (@NonNull Element typedElement : originatingElements) { node.originatingElements.add(typedElement); } - node.setMatched(matched); return node; } @@ -237,17 +233,11 @@ public abstract class MappingNodeImpl extends NodeImpl implements MappingNode { } @Override - public boolean isRequired() { - return isRequired; - } - - @Override public void setOriginatingElement(@NonNull Element originatingElement) { assert getOwningRegion() != null; //instanceof MappingRegion; assert originatingElements.size() == 0; // Should have used addOriginatingElement assert !(originatingElement instanceof Variable); // Should have used setOriginatingVariable originatingElements.add(originatingElement); - isRequired = !(originatingElement instanceof TypedElement) || ((TypedElement)originatingElement).isIsRequired(); } @Override @@ -257,12 +247,10 @@ public abstract class MappingNodeImpl extends NodeImpl implements MappingNode { assert originatingVariable == variable; assert originatingElements.size() == 1; assert originatingElements.contains(variable); - assert isRequired == variable.isIsRequired(); } else if (originatingElements.size() == 0) { // Normal initialization of variable originatingVariable = variable; originatingElements.add(variable); - isRequired = variable.isIsRequired(); } else { // Binding of a variable to its initializer assert !originatingElements.contains(variable); @@ -273,11 +261,6 @@ public abstract class MappingNodeImpl extends NodeImpl implements MappingNode { } @Override - public void setRequired() { - isRequired = true; - } - - @Override public @NonNull String toString() { return super.toString(); } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NavigationEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NavigationEdgeImpl.java index 59dee0780..c066768ea 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NavigationEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NavigationEdgeImpl.java @@ -40,6 +40,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.QVTscheduleFactory; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; /** @@ -291,12 +292,12 @@ public class NavigationEdgeImpl extends NavigableEdgeImpl implements NavigationE switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 8: if (resolve) return getOppositeEdge(); - return basicGetOppositeEdge(); + return basicGetOppositeEdge(); case ElementImpl.ELEMENT_FEATURE_COUNT + 9: return isPartial(); case ElementImpl.ELEMENT_FEATURE_COUNT + 10: if (resolve) return getReferredProperty(); - return basicGetReferredProperty(); + return basicGetReferredProperty(); case ElementImpl.ELEMENT_FEATURE_COUNT + 11: return isSecondary(); } @@ -313,16 +314,16 @@ public class NavigationEdgeImpl extends NavigableEdgeImpl implements NavigationE switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 8: setOppositeEdge((NavigationEdge)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 9: setPartial((Boolean)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setReferredProperty((Property)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 11: setSecondary((Boolean)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -337,16 +338,16 @@ public class NavigationEdgeImpl extends NavigableEdgeImpl implements NavigationE switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 8: setOppositeEdge((NavigationEdge)null); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 9: setPartial(PARTIAL_EDEFAULT); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setReferredProperty((Property)null); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 11: setSecondary(SECONDARY_EDEFAULT); - return; + return; } super.eUnset(featureID); } @@ -468,9 +469,9 @@ public class NavigationEdgeImpl extends NavigableEdgeImpl implements NavigationE } @Override - public @NonNull NavigableEdge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { - NavigationEdge edge = (NavigationEdge)super.createEdge(edgeRole, sourceNode, targetNode); - edge.initializeProperty(QVTscheduleUtil.getReferredProperty(this), isPartial()); + public @NonNull NavigableEdge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { + NavigationEdge edge = (NavigationEdge)super.createEdge(edgeRole, utility, sourceNode, targetNode); + edge.initializeProperty(QVTscheduleUtil.getReferredProperty(this), utility, isPartial()); return edge; } @@ -562,7 +563,7 @@ public class NavigationEdgeImpl extends NavigableEdgeImpl implements NavigationE } @Override - public void initializeProperty(@NonNull Property property, boolean isPartial) { + public void initializeProperty(@NonNull Property property, @NonNull InitUtility utility, boolean isPartial) { setReferredProperty(property); setPartial(isPartial); Property target2sourceProperty = property.getOpposite(); @@ -578,7 +579,7 @@ public class NavigationEdgeImpl extends NavigableEdgeImpl implements NavigationE Node sourceNode2 = sourceNode; assert (edgeRole2 != null) && (sourceNode2 != null); NavigationEdge reverseEdge = QVTscheduleFactory.eINSTANCE.createNavigationEdge(); - reverseEdge.initialize(edgeRole2, targetNode2, target2sourceProperty.getName(), sourceNode2); + reverseEdge.initialize(edgeRole2, utility, targetNode2, target2sourceProperty.getName(), sourceNode2); reverseEdge.setReferredProperty(target2sourceProperty); reverseEdge.setPartial(false /*isPartial()*/); // FIXWE assert false not isPartial() initializeOpposite(reverseEdge); diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NodeImpl.java index bda17ace4..4af0ded08 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NodeImpl.java @@ -36,7 +36,6 @@ import org.eclipse.ocl.pivot.VariableDeclaration; import org.eclipse.ocl.pivot.internal.ElementImpl; import org.eclipse.ocl.pivot.internal.NamedElementImpl; import org.eclipse.ocl.pivot.internal.prettyprint.PrettyPrinter; -import org.eclipse.ocl.pivot.utilities.ClassUtil; import org.eclipse.qvtd.pivot.qvtbase.graphs.GraphStringBuilder; import org.eclipse.qvtd.pivot.qvtbase.graphs.ToGraphHelper; import org.eclipse.qvtd.pivot.qvtschedule.ClassDatum; @@ -51,6 +50,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.QVTscheduleFactory; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Region; import org.eclipse.qvtd.pivot.qvtschedule.Role; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil; /** @@ -492,13 +492,13 @@ public abstract class NodeImpl extends ElementImpl implements Node { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 0: if (resolve) return getClassDatum(); - return basicGetClassDatum(); + return basicGetClassDatum(); case ElementImpl.ELEMENT_FEATURE_COUNT + 1: if (resolve) return getCluster(); - return basicGetCluster(); + return basicGetCluster(); case ElementImpl.ELEMENT_FEATURE_COUNT + 2: if (resolve) return getIncomingConnection(); - return basicGetIncomingConnection(); + return basicGetIncomingConnection(); case ElementImpl.ELEMENT_FEATURE_COUNT + 3: return getIncomingEdges(); case ElementImpl.ELEMENT_FEATURE_COUNT + 4: @@ -526,34 +526,34 @@ public abstract class NodeImpl extends ElementImpl implements Node { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 0: setClassDatum((ClassDatum)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 1: setCluster((Cluster)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 2: setIncomingConnection((NodeConnection)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 3: getIncomingEdges().clear(); - getIncomingEdges().addAll((Collection<? extends Edge>)newValue); - return; + getIncomingEdges().addAll((Collection<? extends Edge>)newValue); + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 4: setName((String)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 5: setNodeRole((Role)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 6: getOutgoingConnections().clear(); - getOutgoingConnections().addAll((Collection<? extends NodeConnection>)newValue); - return; + getOutgoingConnections().addAll((Collection<? extends NodeConnection>)newValue); + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 7: getOutgoingEdges().clear(); - getOutgoingEdges().addAll((Collection<? extends Edge>)newValue); - return; + getOutgoingEdges().addAll((Collection<? extends Edge>)newValue); + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 8: setOwningRegion((Region)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -568,31 +568,31 @@ public abstract class NodeImpl extends ElementImpl implements Node { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 0: setClassDatum((ClassDatum)null); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 1: setCluster((Cluster)null); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 2: setIncomingConnection((NodeConnection)null); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 3: getIncomingEdges().clear(); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 4: setName(NAME_EDEFAULT); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 5: setNodeRole(NODE_ROLE_EDEFAULT); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 6: getOutgoingConnections().clear(); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 7: getOutgoingEdges().clear(); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 8: setOwningRegion((Region)null); - return; + return; } super.eUnset(featureID); } @@ -653,7 +653,7 @@ public abstract class NodeImpl extends ElementImpl implements Node { case ElementImpl.ELEMENT_FEATURE_COUNT + 1: if (cluster != null) msgs = ((InternalEObject)cluster).eInverseRemove(this, NamedElementImpl.NAMED_ELEMENT_FEATURE_COUNT + 2, Cluster.class, msgs); - return basicSetCluster((Cluster)otherEnd, msgs); + return basicSetCluster((Cluster)otherEnd, msgs); case ElementImpl.ELEMENT_FEATURE_COUNT + 3: return ((InternalEList<InternalEObject>)(InternalEList<?>)getIncomingEdges()).basicAdd(otherEnd, msgs); case ElementImpl.ELEMENT_FEATURE_COUNT + 7: @@ -661,7 +661,7 @@ public abstract class NodeImpl extends ElementImpl implements Node { case ElementImpl.ELEMENT_FEATURE_COUNT + 8: if (eInternalContainer() != null) msgs = eBasicRemoveFromContainer(msgs); - return basicSetOwningRegion((Region)otherEnd, msgs); + return basicSetOwningRegion((Region)otherEnd, msgs); } return super.eInverseAdd(otherEnd, featureID, msgs); } @@ -690,8 +690,7 @@ public abstract class NodeImpl extends ElementImpl implements Node { private boolean isHead = false; private boolean isContained = false; private boolean isThis = false; - - private /*@LazyNonNull*/ Utility utility = null; // Set by post region build analysis + private @NonNull InitUtility initUtility = InitUtility.NOT_KNOWN; @Override public void addOriginatingElement(@NonNull Element originatingElement) { @@ -710,9 +709,9 @@ public abstract class NodeImpl extends ElementImpl implements Node { toGraphHelper.setLabel(this); toGraphHelper.setShapeAndStyle(this); toGraphHelper.setColor(this); - if ((utility != null) && !isUnconditional()) { - s.setFillColor(getFillColor()); - } + // if ((utility != null) && !isUnconditional()) { + // s.setFillColor(getFillColor()); + // } toGraphHelper.setPenwidth(this); s.appendAttributedNode(nodeName); // if (isHead) { @@ -731,14 +730,9 @@ public abstract class NodeImpl extends ElementImpl implements Node { } @Override - public @Nullable Utility basicGetUtility() { - return utility; - } - - @Override public @NonNull Node createNode(@NonNull Role nodeRole, @NonNull Region region) { NodeImpl node = (NodeImpl)QVTscheduleFactory.eINSTANCE.create(eClass()); - node.initialize(nodeRole, region, name, classDatum); + node.initialize(nodeRole, region, initUtility, name, classDatum); return node; } @@ -769,7 +763,15 @@ public abstract class NodeImpl extends ElementImpl implements Node { @Override public @NonNull String getColor() { assert nodeRole != null; - return QVTscheduleUtil.getColor(nodeRole); + switch (initUtility) { + case NON_NULL_CONDITIONAL: + case NON_NULL_MATCHED: + case NULLABLE_CONDITIONAL: + case NULLABLE_MATCHED: + return QVTscheduleUtil.getColor(nodeRole); + default: + return QVTscheduleUtil.ERROR_COLOR; + } } @Override @@ -872,46 +874,56 @@ public abstract class NodeImpl extends ElementImpl implements Node { return null; } - @Override public @Nullable String getShape() { return null; } @Override - public @Nullable String getStyle() { + public final @Nullable String getStyle() { StringBuilder s = new StringBuilder(); if (isDataType()) { s.append("rounded"); } - if (!isMatched()) { - if (s.length() > 0) { - s.append(","); + switch (initUtility) { + case NULLABLE_CONDITIONAL: + case NULLABLE_MATCHED: { + if (s.length() > 0) { + s.append(","); + } + s.append("dashed"); + break; } - s.append("dashed"); + case NON_NULL_CONDITIONAL: + case NON_NULL_MATCHED: + break; + default: + break; } - if ((utility != null) && !isUnconditional()) { + /* if ((utility != null) && !isUnconditional()) { + assert / *isComposed() ||* / !isMatched(); if (s.length() > 0) { s.append(","); } s.append("filled"); - } + } */ return "\"" + s.toString() + "\""; } @Override - public @NonNull Utility getUtility() { - return ClassUtil.nonNullState(utility); + public @NonNull InitUtility getInitUtility() { + return initUtility; } @Override - public void initialize(@NonNull Role nodeRole, @NonNull Region region, /*@NonNull*/ String name, /*@NonNull*/ ClassDatum classDatum) { + public void initialize(@NonNull Role nodeRole, @NonNull Region region, @NonNull InitUtility initUtility, /*@NonNull*/ String name, /*@NonNull*/ ClassDatum classDatum) { assert name != null; assert classDatum != null; setNodeRole(nodeRole); setOwningRegion(region); setName(name); setClassDatum(classDatum); + this.initUtility = initUtility; this.isDataType = classDatum.isDataType(); } @@ -932,6 +944,11 @@ public abstract class NodeImpl extends ElementImpl implements Node { } @Override + public final boolean isConditional() { + return initUtility.isConditional(); + } + + @Override public boolean isConstant() { assert nodeRole != null; return nodeRole == Role.CONSTANT; @@ -954,7 +971,7 @@ public abstract class NodeImpl extends ElementImpl implements Node { @Override public boolean isDispatch() { - return getUtility() == Utility.DISPATCH; + return initUtility == InitUtility.DISPATCH; } @Override @@ -984,11 +1001,6 @@ public abstract class NodeImpl extends ElementImpl implements Node { } @Override - public boolean isMatched() { - return false; - } - - @Override public boolean isNew() { assert nodeRole != null; return nodeRole.isNew(); @@ -1035,8 +1047,8 @@ public abstract class NodeImpl extends ElementImpl implements Node { } @Override - public boolean isRequired() { - throw new UnsupportedOperationException(); // Should be MappingNode + public /* final */ boolean isRequired() { + return !initUtility.isNullable(); } @Override @@ -1063,12 +1075,12 @@ public abstract class NodeImpl extends ElementImpl implements Node { @Override public boolean isTrace() { - return getUtility() == Utility.TRACE; + return initUtility == InitUtility.TRACE; } @Override - public boolean isUnconditional() { - return QVTscheduleUtil.isUnconditional(getUtility()); + public final boolean isUnconditional() { + return initUtility.isUnconditional(); } /* @Override @@ -1141,22 +1153,11 @@ public abstract class NodeImpl extends ElementImpl implements Node { } @Override - public void setRequired() { - throw new UnsupportedOperationException(); // Should be MappingNode - } - - @Override public void setThis() { this.isThis = true; } @Override - public void setUtility(@NonNull Utility utility) { - assert (this.utility == null) || (this.utility == utility); - this.utility = utility; - } - - @Override public @NonNull String toString() { Role nodeRole = getNodeRole(); StringBuilder s = new StringBuilder(); diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NullLiteralNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NullLiteralNodeImpl.java index 1670d8eea..8f0ba1b0d 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NullLiteralNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NullLiteralNodeImpl.java @@ -97,11 +97,6 @@ public class NullLiteralNodeImpl extends OperationNodeImpl implements NullLitera } @Override - public @Nullable String getStyle() { - return "rounded"; - } - - @Override public boolean isNullLiteral() { return true; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NumericLiteralNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NumericLiteralNodeImpl.java index 5650e8669..26238c2db 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NumericLiteralNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/NumericLiteralNodeImpl.java @@ -148,7 +148,7 @@ public class NumericLiteralNodeImpl extends OperationNodeImpl implements Numeric switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setNumericValue((Number)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -163,7 +163,7 @@ public class NumericLiteralNodeImpl extends OperationNodeImpl implements Numeric switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setNumericValue(NUMERIC_VALUE_EDEFAULT); - return; + return; } super.eUnset(featureID); } @@ -211,11 +211,6 @@ public class NumericLiteralNodeImpl extends OperationNodeImpl implements Numeric } @Override - public @Nullable String getStyle() { - return "rounded"; - } - - @Override public boolean isPrimitive() { return true; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationCallNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationCallNodeImpl.java index 21300593a..1f22a0d47 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationCallNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationCallNodeImpl.java @@ -141,7 +141,7 @@ public class OperationCallNodeImpl extends OperationNodeImpl implements Operatio switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: if (resolve) return getReferredOperation(); - return basicGetReferredOperation(); + return basicGetReferredOperation(); } return super.eGet(featureID, resolve, coreType); } @@ -156,7 +156,7 @@ public class OperationCallNodeImpl extends OperationNodeImpl implements Operatio switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setReferredOperation((Operation)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -171,7 +171,7 @@ public class OperationCallNodeImpl extends OperationNodeImpl implements Operatio switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setReferredOperation((Operation)null); - return; + return; } super.eUnset(featureID); } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationParameterEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationParameterEdgeImpl.java index ad183bbc6..1d528cee0 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationParameterEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationParameterEdgeImpl.java @@ -33,6 +33,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.OperationParameterEdge; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -189,7 +190,7 @@ public class OperationParameterEdgeImpl extends ArgumentEdgeImpl implements Oper switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: if (resolve) return getReferredParameter(); - return basicGetReferredParameter(); + return basicGetReferredParameter(); case ElementImpl.ELEMENT_FEATURE_COUNT + 7: return getParameterIndex(); } @@ -206,10 +207,10 @@ public class OperationParameterEdgeImpl extends ArgumentEdgeImpl implements Oper switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredParameter((Parameter)newValue); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 7: setParameterIndex((Integer)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -224,10 +225,10 @@ public class OperationParameterEdgeImpl extends ArgumentEdgeImpl implements Oper switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredParameter((Parameter)null); - return; + return; case ElementImpl.ELEMENT_FEATURE_COUNT + 7: setParameterIndex(PARAMETER_INDEX_EDEFAULT); - return; + return; } super.eUnset(featureID); } @@ -264,8 +265,8 @@ public class OperationParameterEdgeImpl extends ArgumentEdgeImpl implements Oper } @Override - public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { - OperationParameterEdge newEdge = (OperationParameterEdge) super.createEdge(edgeRole, sourceNode, targetNode); + public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { + OperationParameterEdge newEdge = (OperationParameterEdge) super.createEdge(edgeRole, utility, sourceNode, targetNode); newEdge.setParameterIndex(getParameterIndex()); newEdge.setReferredParameter(getReferredParameter()); return newEdge; diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationSelfEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationSelfEdgeImpl.java index cfd5a8be1..885dcd652 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationSelfEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/OperationSelfEdgeImpl.java @@ -32,6 +32,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.OperationSelfEdge; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -142,7 +143,7 @@ public class OperationSelfEdgeImpl extends ArgumentEdgeImpl implements Operation switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: if (resolve) return getReferredType(); - return basicGetReferredType(); + return basicGetReferredType(); } return super.eGet(featureID, resolve, coreType); } @@ -157,7 +158,7 @@ public class OperationSelfEdgeImpl extends ArgumentEdgeImpl implements Operation switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredType((Type)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -172,7 +173,7 @@ public class OperationSelfEdgeImpl extends ArgumentEdgeImpl implements Operation switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredType((Type)null); - return; + return; } super.eUnset(featureID); } @@ -207,8 +208,8 @@ public class OperationSelfEdgeImpl extends ArgumentEdgeImpl implements Operation } @Override - public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { - OperationSelfEdge newEdge = (OperationSelfEdge) super.createEdge(edgeRole, sourceNode, targetNode); + public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { + OperationSelfEdge newEdge = (OperationSelfEdge) super.createEdge(edgeRole, utility, sourceNode, targetNode); newEdge.setReferredType(getReferredType()); return newEdge; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/PatternTypedNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/PatternTypedNodeImpl.java index 82ffb0561..69e415612 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/PatternTypedNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/PatternTypedNodeImpl.java @@ -17,11 +17,8 @@ package org.eclipse.qvtd.pivot.qvtschedule.impl; import org.eclipse.emf.ecore.EClass; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.ocl.pivot.util.Visitor; -import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.PatternTypedNode; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; -import org.eclipse.qvtd.pivot.qvtschedule.Region; -import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; /** @@ -89,13 +86,6 @@ public class PatternTypedNodeImpl extends MappingNodeImpl implements PatternType } @Override - public @NonNull Node createNode(@NonNull Role nodeRole, @NonNull Region region) { - PatternTypedNodeImpl node = (PatternTypedNodeImpl)super.createNode(nodeRole, region); - node.setMatched(matched); - return node; - } - - @Override public boolean isPattern() { return true; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/RecursionEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/RecursionEdgeImpl.java index 27b30d726..1248b6ea6 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/RecursionEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/RecursionEdgeImpl.java @@ -27,6 +27,7 @@ import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.RecursionEdge; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleConstants; /** @@ -144,7 +145,7 @@ public class RecursionEdgeImpl extends EdgeImpl implements RecursionEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setPrimary((Boolean)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -159,7 +160,7 @@ public class RecursionEdgeImpl extends EdgeImpl implements RecursionEdge { switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setPrimary(PRIMARY_EDEFAULT); - return; + return; } super.eUnset(featureID); } @@ -199,8 +200,8 @@ public class RecursionEdgeImpl extends EdgeImpl implements RecursionEdge { } @Override - public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { - RecursionEdgeImpl edge = (RecursionEdgeImpl) super.createEdge(edgeRole, sourceNode, targetNode); + public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { + RecursionEdgeImpl edge = (RecursionEdgeImpl) super.createEdge(edgeRole, utility, sourceNode, targetNode); edge.setPrimary(primary); return edge; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/ShadowPartEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/ShadowPartEdgeImpl.java index 88c95e403..bc9556bbb 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/ShadowPartEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/ShadowPartEdgeImpl.java @@ -32,8 +32,8 @@ import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.ShadowPartEdge; - import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -144,7 +144,7 @@ public class ShadowPartEdgeImpl extends ArgumentEdgeImpl implements ShadowPartEd switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: if (resolve) return getReferredPart(); - return basicGetReferredPart(); + return basicGetReferredPart(); } return super.eGet(featureID, resolve, coreType); } @@ -159,7 +159,7 @@ public class ShadowPartEdgeImpl extends ArgumentEdgeImpl implements ShadowPartEd switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((ShadowPart)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -174,7 +174,7 @@ public class ShadowPartEdgeImpl extends ArgumentEdgeImpl implements ShadowPartEd switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((ShadowPart)null); - return; + return; } super.eUnset(featureID); } @@ -209,8 +209,8 @@ public class ShadowPartEdgeImpl extends ArgumentEdgeImpl implements ShadowPartEd } @Override - public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { - ShadowPartEdge newEdge = (ShadowPartEdge) super.createEdge(edgeRole, sourceNode, targetNode); + public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { + ShadowPartEdge newEdge = (ShadowPartEdge) super.createEdge(edgeRole, utility, sourceNode, targetNode); newEdge.setReferredPart(getReferredPart()); return newEdge; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/StringLiteralNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/StringLiteralNodeImpl.java index 7703e2550..87c93b326 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/StringLiteralNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/StringLiteralNodeImpl.java @@ -149,7 +149,7 @@ public class StringLiteralNodeImpl extends OperationNodeImpl implements StringLi switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setStringValue((String)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -164,7 +164,7 @@ public class StringLiteralNodeImpl extends OperationNodeImpl implements StringLi switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 10: setStringValue(STRING_VALUE_EDEFAULT); - return; + return; } super.eUnset(featureID); } @@ -212,11 +212,6 @@ public class StringLiteralNodeImpl extends OperationNodeImpl implements StringLi } @Override - public @Nullable String getStyle() { - return "rounded"; - } - - @Override public boolean isPrimitive() { return true; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/SuccessNodeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/SuccessNodeImpl.java index da7bb6129..906ae2549 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/SuccessNodeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/SuccessNodeImpl.java @@ -85,11 +85,6 @@ public class SuccessNodeImpl extends MappingNodeImpl implements SuccessNode { } @Override - public boolean isMatched() { - return true; - } - - @Override public boolean isPattern() { return true; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/TuplePartEdgeImpl.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/TuplePartEdgeImpl.java index 4a8ec89a1..896db4fed 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/TuplePartEdgeImpl.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/emf-gen/org/eclipse/qvtd/pivot/qvtschedule/impl/TuplePartEdgeImpl.java @@ -32,8 +32,8 @@ import org.eclipse.qvtd.pivot.qvtschedule.Node; import org.eclipse.qvtd.pivot.qvtschedule.QVTschedulePackage; import org.eclipse.qvtd.pivot.qvtschedule.Role; import org.eclipse.qvtd.pivot.qvtschedule.TuplePartEdge; - import org.eclipse.qvtd.pivot.qvtschedule.util.QVTscheduleVisitor; +import org.eclipse.qvtd.pivot.qvtschedule.utilities.InitUtility; /** * <!-- begin-user-doc --> @@ -144,7 +144,7 @@ public class TuplePartEdgeImpl extends ArgumentEdgeImpl implements TuplePartEdge switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: if (resolve) return getReferredPart(); - return basicGetReferredPart(); + return basicGetReferredPart(); } return super.eGet(featureID, resolve, coreType); } @@ -159,7 +159,7 @@ public class TuplePartEdgeImpl extends ArgumentEdgeImpl implements TuplePartEdge switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((TupleLiteralPart)newValue); - return; + return; } super.eSet(featureID, newValue); } @@ -174,7 +174,7 @@ public class TuplePartEdgeImpl extends ArgumentEdgeImpl implements TuplePartEdge switch (featureID) { case ElementImpl.ELEMENT_FEATURE_COUNT + 6: setReferredPart((TupleLiteralPart)null); - return; + return; } super.eUnset(featureID); } @@ -209,8 +209,8 @@ public class TuplePartEdgeImpl extends ArgumentEdgeImpl implements TuplePartEdge } @Override - public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull Node sourceNode, @NonNull Node targetNode) { - TuplePartEdge newEdge = (TuplePartEdge) super.createEdge(edgeRole, sourceNode, targetNode); + public @NonNull Edge createEdge(@NonNull Role edgeRole, @NonNull InitUtility utility, @NonNull Node sourceNode, @NonNull Node targetNode) { + TuplePartEdge newEdge = (TuplePartEdge) super.createEdge(edgeRole, utility, sourceNode, targetNode); newEdge.setReferredPart(getReferredPart()); return newEdge; } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/AbstractToGraphVisitor.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/AbstractToGraphVisitor.java index 636f90024..debe749e4 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/AbstractToGraphVisitor.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/AbstractToGraphVisitor.java @@ -149,6 +149,19 @@ public abstract class AbstractToGraphVisitor extends AbstractExtendingQVTschedul return style; } + protected boolean isConditional(GraphNode graphNode) { + boolean isConditional = false; + if (graphNode instanceof Node) { + Node node = (Node) graphNode; + isConditional = node.getInitUtility().isConditional(); + } + else if (graphNode instanceof Edge) { + Edge edge = (Edge) graphNode; + isConditional = edge.getInitUtility().isConditional(); + } + return isConditional; + } + protected boolean isExpression(GraphNode graphNode) { boolean isExpression = false; if (graphNode instanceof Node) { @@ -190,7 +203,7 @@ public abstract class AbstractToGraphVisitor extends AbstractExtendingQVTschedul @Override public void setPenwidth(@NonNull GraphNode graphNode) { boolean isHead = isHead(graphNode); - boolean isExpression = isExpression(graphNode); + boolean isExpression = /*isExpression*/isConditional(graphNode); context.setPenwidth(isHead ? QVTscheduleConstants.HEAD_WIDTH : !isExpression ? 2*QVTscheduleConstants.LINE_WIDTH : QVTscheduleConstants.LINE_WIDTH); } diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/InitUtility.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/InitUtility.java new file mode 100644 index 000000000..d79de97c0 --- /dev/null +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/InitUtility.java @@ -0,0 +1,85 @@ +/** + * <copyright> + * + * Copyright (c) 2019 Willink Transformations and others. + * All rights reserved. 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 + * http://www.eclipse.org/legal/epl-v20.html + * + * Contributors: + * E.D.Willink - Initial API and implementation + * + * </copyright> + */ +package org.eclipse.qvtd.pivot.qvtschedule.utilities; + +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.ocl.pivot.TypedElement; + +public enum InitUtility { + /** The predicated dispatcher of an overriding rule (the overridden dispatcher is a TRACE).*/ + DISPATCH, + /** The predicated/realized trace node.*/ + TRACE, + /** The success node to which the match/not-match verdict is assigned.*/ + SUCCESS, + /** A dependency that must be satisfied to validate the region's execution.*/ + DEPENDENCY, + /** A LoadingRegion element.*/ + COMPOSED, + /** Non-null value reachable by to-1 navigation from the (?? a) trace node, or by to-? to an ExplicitNull.*/ + NON_NULL_MATCHED, + /** Maybe-null value reachable by to-1 navigation from the (?? a) trace node, or by to-? to an ExplicitNull.*/ + NULLABLE_MATCHED, + /** A non-null selectively computable element depending on if conditions / loops. Not matched.*/ + NON_NULL_CONDITIONAL, + /** A maybe-null selectively computable element depending on if conditions / loops. Not matched.*/ + NULLABLE_CONDITIONAL, + NOT_KNOWN; + + public static @NonNull InitUtility getRequiredInitUtility(@NonNull TypedElement typedElement) { + return typedElement.isIsRequired() ? InitUtility.NON_NULL_MATCHED : InitUtility.NULLABLE_MATCHED; + } + + public @NonNull InitUtility getConditionalUtility() { + switch(this) { + case NON_NULL_CONDITIONAL: return NON_NULL_CONDITIONAL; + case NON_NULL_MATCHED: return NON_NULL_CONDITIONAL; + case NULLABLE_CONDITIONAL: return NULLABLE_CONDITIONAL; + case NULLABLE_MATCHED: return NULLABLE_CONDITIONAL; + } + throw new UnsupportedOperationException(); + } + + public @NonNull InitUtility getNullableUtility() { + switch(this) { + case NON_NULL_CONDITIONAL: return NULLABLE_CONDITIONAL; + case NON_NULL_MATCHED: return NULLABLE_MATCHED; + case NULLABLE_CONDITIONAL: return NULLABLE_CONDITIONAL; + case NULLABLE_MATCHED: return NULLABLE_MATCHED; + } + throw new UnsupportedOperationException(); + } + + /** + * Return true for a conditional pattern usage. + */ + public boolean isConditional() { + return (this == NON_NULL_CONDITIONAL) || (this == NULLABLE_CONDITIONAL); + } + + /** + * Return true for a nullable pattern usage. + */ + public boolean isNullable() { + return (this == InitUtility.NULLABLE_MATCHED) || (this == NULLABLE_CONDITIONAL); + } + + /** + * Return true for an unconditioknal pattern usage. + */ + public boolean isUnconditional() { + return (this == InitUtility.NON_NULL_MATCHED) || (this == InitUtility.NULLABLE_MATCHED) || (this == TRACE) || (this == DISPATCH); + } +}
\ No newline at end of file diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/QVTscheduleUtil.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/QVTscheduleUtil.java index cf51903c5..17df4881a 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/QVTscheduleUtil.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/QVTscheduleUtil.java @@ -17,19 +17,13 @@ import java.util.function.BinaryOperator; import org.eclipse.emf.ecore.EObject; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; -import org.eclipse.ocl.pivot.CollectionType; import org.eclipse.ocl.pivot.CompleteClass; import org.eclipse.ocl.pivot.Element; import org.eclipse.ocl.pivot.EnumerationLiteral; -import org.eclipse.ocl.pivot.IfExp; -import org.eclipse.ocl.pivot.LoopExp; -import org.eclipse.ocl.pivot.MapLiteralPart; -import org.eclipse.ocl.pivot.OCLExpression; import org.eclipse.ocl.pivot.Operation; import org.eclipse.ocl.pivot.OperationCallExp; import org.eclipse.ocl.pivot.Property; import org.eclipse.ocl.pivot.ShadowPart; -import org.eclipse.ocl.pivot.Type; import org.eclipse.ocl.pivot.TypedElement; import org.eclipse.ocl.pivot.utilities.ClassUtil; import org.eclipse.ocl.pivot.utilities.Nameable; @@ -67,7 +61,6 @@ import org.eclipse.qvtd.pivot.qvtschedule.RootPartition; import org.eclipse.qvtd.pivot.qvtschedule.ScheduleModel; import org.eclipse.qvtd.pivot.qvtschedule.ShadowPartEdge; import org.eclipse.qvtd.pivot.qvtschedule.RootRegion; -import org.eclipse.qvtd.pivot.qvtschedule.Node.Utility; public class QVTscheduleUtil extends QVTscheduleConstants { @@ -734,30 +727,6 @@ public class QVTscheduleUtil extends QVTscheduleConstants return false; } - public static boolean isMatched(@NonNull Element element) { - if (element instanceof MapLiteralPart) { - MapLiteralPart mapLiteralPart = (MapLiteralPart)element; - OCLExpression key = QVTbaseUtil.getOwnedKey(mapLiteralPart); - OCLExpression value = QVTbaseUtil.getOwnedValue(mapLiteralPart); - return isMatched(key) && isMatched(value); - } - else if (element instanceof TypedElement) { - TypedElement typedElement = (TypedElement)element; - Type type = typedElement.getType(); - if (type instanceof CollectionType) { - // IntegerValue lowerValue = ((CollectionType)type).getLowerValue(); - // if (lowerValue.signum() > 0) { - assert typedElement.isIsRequired(); - // } - } - else if (!typedElement.isIsRequired()) { - return false; - } - return isUnconditional(typedElement); - } - throw new UnsupportedOperationException(); - } - /* public static boolean isRealizedIncludes(@NonNull Edge edge) { // FIXME includes should be a pseudo-navigation edge if (!edge.isRealized()) { return false; @@ -768,30 +737,6 @@ public class QVTscheduleUtil extends QVTscheduleConstants return "«includes»".equals(edge.getName()) || "«includesAll»".equals(edge.getName()); } */ - public static boolean isUnconditional(@NonNull TypedElement typedElement) { - EObject eContainer = typedElement.eContainer(); - if (eContainer instanceof IfExp) { - IfExp ifExp = (IfExp)eContainer; - if ((typedElement == ifExp.getOwnedThen()) || (typedElement == ifExp.getOwnedElse())) { - return false; - } - } - else if (eContainer instanceof LoopExp) { - LoopExp loopExp = (LoopExp)eContainer; - if (typedElement == loopExp.getOwnedBody()) { - return false; - } - } - if (eContainer instanceof TypedElement) { - return isUnconditional((TypedElement) eContainer); - } - return true; - } - - public static boolean isUnconditional(@Nullable Utility utility) { - return (utility == Utility.DISPATCH) || (utility == Utility.TRACE) || (utility == Utility.STRONGLY_MATCHED) || (utility == Utility.WEAKLY_MATCHED); - } - public static @NonNull Role mergeToLessKnownPhase(Role firstRole, Role secondRole) { if (firstRole == Role.REALIZED) { return firstRole; @@ -866,7 +811,7 @@ public class QVTscheduleUtil extends QVTscheduleConstants throw new UnsupportedOperationException(); } - public static Node.@NonNull Utility mergeToStrongerUtility(Node.@NonNull Utility nodeUtility1, Node.@NonNull Utility nodeUtility2) { + /* public static Node.@NonNull Utility mergeToStrongerUtility(Node.@NonNull Utility nodeUtility1, Node.@NonNull Utility nodeUtility2) { if (nodeUtility1 == Node.Utility.DISPATCH) { assert (nodeUtility2 == Node.Utility.DISPATCH); return Node.Utility.DISPATCH; @@ -890,7 +835,7 @@ public class QVTscheduleUtil extends QVTscheduleConstants else { return Node.Utility.DEAD; } - } + } */ public static @NonNull BinaryOperator<@NonNull String> stringJoin(@NonNull String delimiter) { return (a, b) -> String.valueOf(a) + delimiter + String.valueOf(b); diff --git a/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/ToGraphPartitionVisitor.java b/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/ToGraphPartitionVisitor.java index 77b0bd5b5..d678368e1 100644 --- a/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/ToGraphPartitionVisitor.java +++ b/plugins/org.eclipse.qvtd.pivot.qvtschedule/src/org/eclipse/qvtd/pivot/qvtschedule/utilities/ToGraphPartitionVisitor.java @@ -279,6 +279,19 @@ public abstract class ToGraphPartitionVisitor extends AbstractToGraphVisitor @Override protected @NonNull String getColor(@NonNull GraphElement element) { + InitUtility initUtility = null; + if (element instanceof Node) { + initUtility = ((Node)element).getInitUtility(); + } + else if (element instanceof Edge) { + initUtility = ((Edge)element).getInitUtility(); + } + else { + initUtility = InitUtility.NOT_KNOWN; + } + if (initUtility == InitUtility.NOT_KNOWN) { + return QVTscheduleUtil.ERROR_COLOR; + } Role role = getGraphRole(element); if (role != null) { return QVTscheduleUtil.getColor(role); @@ -310,24 +323,6 @@ public abstract class ToGraphPartitionVisitor extends AbstractToGraphVisitor } @Override - protected @Nullable String getShape(@NonNull GraphNode graphNode) { - Role role = getGraphRole(graphNode); - if ((role == Role.CONSTANT_SUCCESS_FALSE) || (role == Role.CONSTANT_SUCCESS_TRUE)) { - return null; // rectangle - } - return super.getShape(graphNode); - } - - @Override - protected @Nullable String getStyle(@NonNull GraphNode graphNode) { - Role role = getGraphRole(graphNode); - if ((role == Role.CONSTANT_SUCCESS_FALSE) || (role == Role.CONSTANT_SUCCESS_TRUE)) { - return "rounded"; - } - return super.getStyle(graphNode); - } - - @Override protected boolean isHead(@NonNull GraphNode graphNode) { if (partition != null) { return partition.isHead((Node)graphNode); |