| /******************************************************************************* |
| * Copyright (c) 2009, 2018 SAP AG 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: |
| * SAP AG - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.ocl.examples.impactanalyzer.instanceScope.traceback; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.Stack; |
| |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EClassifier; |
| import org.eclipse.emf.ecore.ENamedElement; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EOperation; |
| import org.eclipse.emf.ecore.EParameter; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.ocl.ecore.CollectionType; |
| import org.eclipse.ocl.ecore.EcorePackage; |
| import org.eclipse.ocl.ecore.IfExp; |
| import org.eclipse.ocl.ecore.IterateExp; |
| import org.eclipse.ocl.ecore.LetExp; |
| import org.eclipse.ocl.ecore.LoopExp; |
| import org.eclipse.ocl.ecore.OCL; |
| import org.eclipse.ocl.ecore.OCLExpression; |
| import org.eclipse.ocl.ecore.OperationCallExp; |
| import org.eclipse.ocl.ecore.TupleType; |
| import org.eclipse.ocl.ecore.Variable; |
| import org.eclipse.ocl.ecore.VariableExp; |
| import org.eclipse.ocl.ecore.opposites.OppositeEndFinder; |
| import org.eclipse.ocl.examples.impactanalyzer.configuration.OptimizationActivation; |
| import org.eclipse.ocl.examples.impactanalyzer.deltaPropagation.PartialEvaluatorImpl; |
| import org.eclipse.ocl.examples.impactanalyzer.impl.OperationBodyToCallMapper; |
| import org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation.UnusedEvaluationRequest; |
| import org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation.UnusedEvaluationRequestFactory; |
| import org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation.UnusedEvaluationRequestSet; |
| import org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation.UnusedEvaluationRequestSet.UnusedEvaluationResult; |
| import org.eclipse.ocl.examples.impactanalyzer.util.AnnotatedEObject; |
| import org.eclipse.ocl.examples.impactanalyzer.util.HighlightingToStringVisitor; |
| import org.eclipse.ocl.examples.impactanalyzer.util.OCLFactory; |
| import org.eclipse.ocl.examples.impactanalyzer.util.OclHelper; |
| import org.eclipse.ocl.examples.impactanalyzer.util.OperationCallExpKeyedSet; |
| import org.eclipse.ocl.examples.impactanalyzer.util.Tuple.Pair; |
| |
| public abstract class AbstractTracebackStep<E extends OCLExpression> implements TracebackStep { |
| /** |
| * If set to a non-<code>null</code> class, this step asserts that if the source objects passed to its |
| * {@link #traceback(AnnotatedEObject, UnusedEvaluationRequestSet, TracebackCache, Notification)} |
| * operation are not compatible to that |
| * type, then the result set will be empty. |
| */ |
| protected EClass requiredType; |
| |
| /** |
| * The OCL expression for which this is the traceback step |
| */ |
| private final E expression; |
| |
| /** |
| * Descriptions of the partial evaluations to perform when executing this step, in order to try to prove that the |
| * {@link #expression} is unused by the particular change currently being traced back. |
| * |
| * @see #determineUnusedEvaluationRequests(OCLExpression, OperationBodyToCallMapper, UnusedEvaluationRequestFactory) |
| */ |
| private final Set<UnusedEvaluationRequest> unusedEvaluationRequests; |
| |
| /** |
| * To avoid endless recursions, a step remembers for which combinations of <code>source</code> objects and |
| * {@link UnusedEvaluationRequestSet}s it is currently executing. If any of those combinations is to be evaluated |
| * again while already being evaluated by the current thread, an empty set is returned. It uses the two attributes |
| * {@link #currentlyEvaluatingTracebackFor} and {@link #listOfKeysCurrentlyEvaluatingTracebackFor} for this purpose to |
| * be memory-economic. If not evaluating for any key, both are <code>null</code>. If evaluating for a single key, |
| * that key is stored in {@link #currentlyEvaluatingTracebackFor}. If evaluating for multiple objects, |
| * {@link #currentlyEvaluatingTracebackFor} is <code>null</code>, and {@link #listOfKeysCurrentlyEvaluatingTracebackFor} |
| * holds a collection of keys for which the step is currently evaluating.<p> |
| * |
| * @see #startEvaluationFor(Pair) |
| * @see #finishedEvaluationFor(Pair) |
| * @see #isCurrentlyEvaluatingFor(Pair) |
| */ |
| private Pair<AnnotatedEObject, UnusedEvaluationRequestSet> currentlyEvaluatingTracebackFor; |
| private Collection<Pair<AnnotatedEObject, UnusedEvaluationRequestSet>> listOfKeysCurrentlyEvaluatingTracebackFor; |
| |
| private final OppositeEndFinder oppositeEndFinder; |
| |
| /** |
| * Used in "debug" mode, storing this step's annotation string to be used in {@link AnnotatedEObject}s to explain how |
| * a result was inferred. |
| */ |
| private final String annotation; |
| |
| protected final OCLFactory oclFactory; |
| |
| public static int tracebackExecutions = 0; |
| public static int provenUnused = 0; |
| |
| /** |
| * Encapsulates the scope change that has to happen before invoking a subsequent traceback step. |
| * @author Axel Uhl (D043530) |
| */ |
| public static class TracebackStepAndScopeChange implements TracebackStep { |
| private final TracebackStep step; |
| private final Set<Variable> variablesThatLeaveOrEnterScopeWhenCallingStep; |
| |
| public TracebackStepAndScopeChange(TracebackStep step, Set<Variable> variablesThatLeaveOrEnterScopeWhenCallingStep) { |
| this.step = step; |
| this.variablesThatLeaveOrEnterScopeWhenCallingStep = variablesThatLeaveOrEnterScopeWhenCallingStep; |
| } |
| |
| public OperationCallExpKeyedSet traceback(AnnotatedEObject source, UnusedEvaluationRequestSet pendingUnusedEvalRequests, |
| org.eclipse.ocl.examples.impactanalyzer.instanceScope.traceback.TracebackCache tracebackCache, Notification changeEvent) { |
| UnusedEvaluationRequestSet reducedUnusedEvaluationRequestSet; |
| if (tracebackCache.getConfiguration().isUnusedDetectionActive()) { |
| reducedUnusedEvaluationRequestSet = pendingUnusedEvalRequests == null ? null |
| : pendingUnusedEvalRequests.createReducedSet(variablesThatLeaveOrEnterScopeWhenCallingStep, |
| tracebackCache.getUnusedEvaluationRequestFactory()); |
| } else { |
| reducedUnusedEvaluationRequestSet = null; |
| } |
| return step.traceback(source, reducedUnusedEvaluationRequestSet, tracebackCache, changeEvent); |
| } |
| |
| public String toString() { |
| StringBuilder result = new StringBuilder("Unscope "); |
| for (Variable v : variablesThatLeaveOrEnterScopeWhenCallingStep) { |
| result.append(v.getName()); |
| result.append(", "); |
| } |
| result.append("then perform "); |
| result.append(step); |
| return result.toString(); |
| } |
| } |
| |
| /** |
| * When executed using the {@link #traceback(AnnotatedEObject, UnusedEvaluationRequestSet, TracebackCache, Notification)} method, |
| * results will be keyed with {@link #callToWhichResultsAreSpecific} because the {@link TracebackStep} encapsulated by this object |
| * navigates back to the specified call expression, and there either to the source or an argument expression. |
| * |
| * @see OperationCallExpKeyedSet |
| * @author Axel Uhl (D043530) |
| * |
| */ |
| protected static class TracebackStepAndScopeChangeWithOperationCallExp extends TracebackStepAndScopeChange { |
| private final OperationCallExp callToWhichResultsAreSpecific; |
| |
| /** |
| * Remembers <code>call</code> as the only operation call through which |
| * @param step |
| * @param variablesChangingScope |
| * @param callToWhichResultsAreSpecific |
| */ |
| public TracebackStepAndScopeChangeWithOperationCallExp(TracebackStep step, Set<Variable> variablesChangingScope, |
| OperationCallExp callToWhichResultsAreSpecific) { |
| super(step, variablesChangingScope); |
| this.callToWhichResultsAreSpecific = callToWhichResultsAreSpecific; |
| } |
| |
| public OperationCallExpKeyedSet traceback(AnnotatedEObject source, UnusedEvaluationRequestSet pendingUnusedEvalRequests, |
| org.eclipse.ocl.examples.impactanalyzer.instanceScope.traceback.TracebackCache tracebackCache, |
| Notification changeEvent) { |
| OperationCallExpKeyedSet resultsForSourceOrArgument = super.traceback(source, pendingUnusedEvalRequests, |
| tracebackCache, changeEvent); |
| OperationCallExpKeyedSet result = tracebackCache.getOperationCallExpKeyedSetFactory().createOperationCallExpKeyedSet( |
| callToWhichResultsAreSpecific, resultsForSourceOrArgument); |
| return result; |
| } |
| |
| public String toString() { |
| StringBuilder result = new StringBuilder(super.toString()); |
| result.append(", then filter for results specific to OperationCallExp "); |
| result.append(callToWhichResultsAreSpecific); |
| return result.toString(); |
| } |
| } |
| |
| /** |
| * If the expression's type for which this traceback step is constructed is class-like, {@link #requiredType} is set to the |
| * expression's type. |
| * @param tupleLiteralNamesToLookFor |
| * if a tuple part is being sought, the expression type will be a tuple type; in this case, extract the sought |
| * part's type as the {@link #requiredType}. |
| */ |
| protected AbstractTracebackStep(E sourceExpression, Stack<String> tupleLiteralNamesToLookFor, |
| OppositeEndFinder oppositeEndFinder, OperationBodyToCallMapper operationBodyToCallMapper, |
| UnusedEvaluationRequestFactory unusedEvaluationRequestFactory, OCLFactory oclFactory) { |
| this.expression = sourceExpression; |
| this.oppositeEndFinder = oppositeEndFinder; |
| this.oclFactory = oclFactory; |
| EClassifier type = sourceExpression.getType(); |
| requiredType = getInnermostTypeConsideringTupleLiteralsLookedFor(tupleLiteralNamesToLookFor, type); |
| if (OptimizationActivation.getOption().isUnusedDetectionActive()) { |
| unusedEvaluationRequests = determineUnusedEvaluationRequests(getExpression(), operationBodyToCallMapper, |
| unusedEvaluationRequestFactory); |
| } else { |
| unusedEvaluationRequests = null; |
| } |
| annotation = getVerboseDebugInfo(operationBodyToCallMapper); |
| } |
| |
| /** |
| * There are a few rules for determining, whether a sub-expression is unused under a given set of variable values. |
| * <ul> |
| * <li><b>Unused branch in {@link IfExp}</b>: The {@link IfExp#getThenExpression() then}-expression of an {@link IfExp} is |
| * unused if the {@link IfExp#getCondition() condition} of that {@link IfExp} evaluates to <code>false</code>. Analogously, |
| * the {@link IfExp#getElseExpression() else}-expression of an {@link IfExp} is unused if the {@link IfExp#getCondition() |
| * condition} of that {@link IfExp} evaluates to <code>true</code>.</li> |
| * |
| * <li><b>Unused {@link LetExp let} declaration</b>: the {@link Variable#getInitExpression() initialization expression} for a |
| * <code>let</code>-variable is unused if all {@link VariableExp} expressions referring to that variable are unused within the |
| * {@link LetExp#getIn() in}-expression.</li> |
| * |
| * <li><b>Unused {@link OperationCallExp#getArgument() argument} expression of an operation call</b>: the argument of an |
| * operation call is unused if all {@link VariableExp} expression in the operation body referring to the corresponding formal |
| * parameter are unused.</li> |
| * |
| * <li><b>Unused body of loop over empty collection</b>: The body expression of any {@link LoopExp} expression won't be used |
| * if the {@link LoopExp#getSource() source} of the loop expression evaluates to an empty collection.</li> |
| * |
| * <li><b>Unused element of ordered collection literal in conjunction with <code>->at(...)</code></b>: When the |
| * <code>->at(...)</code> standard library operation is applied to an ordered collection literal and it is possible to |
| * evaluate the argument of the <code>at</code> call, all literal items at other positions than the one identified by the |
| * argument are unused.</li> |
| * |
| * <li><b>Composition rule</b>: An expression is unused if its {@link EObject#eContainer() containing expression} is unused.</li> |
| * </ul> |
| * |
| * Eventually, unused checks perform one or more {@link PartialEvaluatorImpl (partial) evaluations} of expressions which are |
| * reached by navigation across the OCL expression's AST, starting from the expression whose "unusedness" is to be proven. |
| * Similar to the scope changes implied by the AST navigations during |
| * {@link #traceback(AnnotatedEObject, UnusedEvaluationRequestSet, TracebackCache, Notification)}, these navigations leave and |
| * enter dynamic variable scopes. Once a variable's scope is left or a new one entered, we currently don't assume that the |
| * {@link #traceback(AnnotatedEObject, UnusedEvaluationRequestSet, TracebackCache, Notification)} calculation will be able |
| * reliably perform dynamic scope matching. Therefore, we don't expect to be able to infer a variable's value anymore, once |
| * its dynamic scope has been left or (re-)entered. |
| * <p> |
| * |
| * Therefore, this method produces {@link UnusedEvaluationRequest}s which hold slots only for variables that remained in scope |
| * during the AST navigation from the <code>sourceExpression</code> to the expression to be evaluated during the "unused" |
| * check. They are stored in the {@link TracebackStep} whose expression's unusedness they shall prove. When a step is executed |
| * by invoking its {@link #traceback(AnnotatedEObject, UnusedEvaluationRequestSet, TracebackCache, Notification)} method, |
| * these requests are {@link UnusedEvaluationRequest#evaluate(org.eclipse.ocl.ecore.opposites.OppositeEndFinder, OCL) evaluated}. |
| * using {@link UnusedEvaluationRequestSet#evaluate(Set, org.eclipse.ocl.ecore.opposites.OppositeEndFinder, TracebackCache, OCL)}. If this proves |
| * that the expression is unused, an empty set can be returned right away. Otherwise, the follow-up |
| * {@link UnusedEvaluationRequestSet} delivered via {@link UnusedEvaluationResult#getNewRequestSet()} is merged with the one |
| * passed to {@link #traceback(AnnotatedEObject, UnusedEvaluationRequestSet, TracebackCache, Notification)}. |
| * <p> |
| * |
| * It may happen that a <code>let</code>-variable is unknown during a partial evaluation attempt but that its initialization |
| * expression can successfully be evaluated with the variable values inferred. In this case, the <code>let</code>-variable is |
| * <em>indirectly inferred</em>. Similarly, a formal operation parameter may be unknown while trying to prove that it or |
| * another formal parameter is unused. However, these types of unused checks for formal operation parameters may be performed |
| * based on the "Unused {@link OperationCallExp#getArgument() argument} expression of an operation call" rule. In this case, |
| * the argument expressions are known and an attempt can be made to evaluate them. If such an evaluation succeeds, the |
| * evaluation result represents the inferred value of the corresponding formal parameter. |
| * @return the set of evaluation requests with which to try to prove unusedness of the {@link #expression} |
| */ |
| private Set<UnusedEvaluationRequest> determineUnusedEvaluationRequests(OCLExpression e, |
| OperationBodyToCallMapper operationBodyToCallMapper, UnusedEvaluationRequestFactory unusedEvaluationRequestFactory) { |
| Set<UnusedEvaluationRequest> result = new HashSet<UnusedEvaluationRequest>(); |
| OCLExpression root = OclHelper.getRootExpression(e); |
| Set<Variable> variablesInScope = getAllVariablesInScope(e, operationBodyToCallMapper); |
| return determineUnusedEvaluationRequests(e, root, variablesInScope, operationBodyToCallMapper, result, unusedEvaluationRequestFactory); |
| } |
| |
| /** |
| * @param upTo during following the composition rule, ascends up to this expression and no further |
| * @return <code>result</code> |
| */ |
| private Set<UnusedEvaluationRequest> determineUnusedEvaluationRequests(OCLExpression e, OCLExpression upTo, |
| Set<Variable> variablesInScope, OperationBodyToCallMapper operationBodyToCallMapper, Set<UnusedEvaluationRequest> result, UnusedEvaluationRequestFactory unusedEvaluationRequestFactory) { |
| UnusedEvaluationRequest thenClauseRequest = getThenClauseUnusedCheckRequest(e, variablesInScope, operationBodyToCallMapper, unusedEvaluationRequestFactory); |
| if (thenClauseRequest != null) { |
| result.add(thenClauseRequest); |
| } else { |
| UnusedEvaluationRequest elseClauseRequest = getElseClauseUnusedCheckRequest(e, variablesInScope, operationBodyToCallMapper, unusedEvaluationRequestFactory); |
| if (elseClauseRequest != null) { |
| result.add(elseClauseRequest); |
| } else { |
| UnusedEvaluationRequest loopBodyRequest = getLoopBodyUnusedCheckRequest(e, variablesInScope, operationBodyToCallMapper, unusedEvaluationRequestFactory); |
| if (loopBodyRequest != null) { |
| result.add(loopBodyRequest); |
| } else { |
| Set<UnusedEvaluationRequest> letVariableInitRequests = getLetVariableInitUnusedCheckRequests(e, variablesInScope, operationBodyToCallMapper, oppositeEndFinder, unusedEvaluationRequestFactory); |
| if (letVariableInitRequests != null) { |
| result.addAll(letVariableInitRequests); |
| } else { |
| Set<UnusedEvaluationRequest> operationArgumentRequests = getOperationArgumentUnusedCheckRequests(e, variablesInScope, operationBodyToCallMapper); |
| if (operationArgumentRequests != null) { |
| result.addAll(operationArgumentRequests); |
| } else { |
| UnusedEvaluationRequest collectionLiteralWithAtRequest = getCollectionLiteralWithAtUnusedCheckRequest(e, variablesInScope, operationBodyToCallMapper); |
| if (collectionLiteralWithAtRequest != null) { |
| result.add(collectionLiteralWithAtRequest); |
| } |
| } |
| } |
| } |
| } |
| } |
| Set<UnusedEvaluationRequest> compositeParentRequests = getCompositeParentUnusedCheckRequests(e, upTo, |
| variablesInScope, new HashSet<UnusedEvaluationRequest>(), operationBodyToCallMapper, unusedEvaluationRequestFactory); |
| result.addAll(compositeParentRequests); |
| if (result.size() > 0) { |
| return result; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * @param e the expression for which to investigate unusedness |
| * @param upTo during following the composition rule, ascends up to this expression and no further |
| * @param result a set to which to add the results and which to return |
| * @return <code>requestsToAddTo</code> |
| */ |
| private Set<UnusedEvaluationRequest> getCompositeParentUnusedCheckRequests(OCLExpression e, OCLExpression upTo, |
| Set<Variable> variablesInScope, Set<UnusedEvaluationRequest> result, OperationBodyToCallMapper operationBodyToCallMapper, UnusedEvaluationRequestFactory unusedEvaluationRequestFactory) { |
| EObject container = e.eContainer(); |
| while (container != null && !(container instanceof OCLExpression)) { |
| container = container.eContainer(); |
| } |
| if (container != null && container instanceof OCLExpression) { |
| Set<Variable> variablesLeavingScope = getVariablesScopedByExpression(e, operationBodyToCallMapper); |
| Set<Variable> remainingVariablesInScope = new HashSet<Variable>(variablesInScope); |
| remainingVariablesInScope.removeAll(variablesLeavingScope); |
| determineUnusedEvaluationRequests((OCLExpression) container, upTo, remainingVariablesInScope, |
| operationBodyToCallMapper, result, unusedEvaluationRequestFactory); |
| } |
| return result; |
| } |
| |
| private UnusedEvaluationRequest getCollectionLiteralWithAtUnusedCheckRequest(OCLExpression e, Set<Variable> variablesInScope, |
| OperationBodyToCallMapper operationBodyToCallMapper) { |
| // TODO Implement AbstractTracebackStep.getCollectionLiteralWithAtUnusedCheckRequest(...) |
| return null; |
| } |
| |
| private Set<UnusedEvaluationRequest> getOperationArgumentUnusedCheckRequests(OCLExpression e, Set<Variable> variablesInScope, |
| OperationBodyToCallMapper operationBodyToCallMapper) { |
| // TODO Implement AbstractTracebackStep.getOperationArgumentUnusedCheckRequests(...) |
| return null; |
| } |
| |
| private Set<UnusedEvaluationRequest> getLetVariableInitUnusedCheckRequests(OCLExpression e, Set<Variable> variablesInScope, |
| OperationBodyToCallMapper operationBodyToCallMapper, OppositeEndFinder oppositeEndFinder, UnusedEvaluationRequestFactory unusedEvaluationRequestFactory) { |
| Set<UnusedEvaluationRequest> result = new HashSet<UnusedEvaluationRequest>(); |
| EObject container = e.eContainer(); |
| if (container != null && container instanceof Variable && ((Variable) container).getInitExpression() == e) { |
| EObject letCandidate = container.eContainer(); |
| if (letCandidate instanceof LetExp && ((LetExp) letCandidate).getIn() == e) { |
| Collection<EObject> variableExps = oppositeEndFinder.navigateOppositePropertyWithBackwardScope( |
| (EReference) EcorePackage.eINSTANCE.getVariableExp().getEStructuralFeature( |
| EcorePackage.VARIABLE_EXP__REFERRED_VARIABLE), container); |
| for (EObject ve : variableExps) { |
| VariableExp variableExp = (VariableExp) ve; |
| Set<Variable> variableScopeChange = getVariablesChangingScope(e, variableExp, operationBodyToCallMapper); |
| Set<Variable> newScope = new HashSet<Variable>(variablesInScope); |
| newScope.removeAll(variableScopeChange); |
| determineUnusedEvaluationRequests(variableExp, |
| /* up to */ (OCLExpression) ((LetExp) letCandidate).getIn(), |
| newScope, operationBodyToCallMapper, result, unusedEvaluationRequestFactory); |
| } |
| } |
| } |
| return result; |
| } |
| |
| private UnusedEvaluationRequest getLoopBodyUnusedCheckRequest(OCLExpression e, Set<Variable> variablesInScope, |
| OperationBodyToCallMapper operationBodyToCallMapper, UnusedEvaluationRequestFactory unusedEvaluationRequestFactory) { |
| UnusedEvaluationRequest result = null; |
| EObject container = e.eContainer(); |
| if (container instanceof LoopExp && ((LoopExp) container).getBody() == e) { |
| Set<Variable> variablesInScopeReducedByIteratorsAndResult = new HashSet<Variable>(variablesInScope); |
| variablesInScopeReducedByIteratorsAndResult.removeAll(((LoopExp) container).getIterator()); |
| if (container instanceof IterateExp) { |
| Variable resultVariable = (Variable) ((IterateExp) container).getResult(); |
| if (resultVariable != null) { |
| variablesInScopeReducedByIteratorsAndResult.remove(resultVariable); |
| } |
| } |
| result = unusedEvaluationRequestFactory.getUnusedEvaluationRequest((OCLExpression) ((LoopExp) container).getSource(), |
| /* unused if */ null /* meaning empty */, null, variablesInScopeReducedByIteratorsAndResult); |
| } |
| return result; |
| } |
| |
| private UnusedEvaluationRequest getElseClauseUnusedCheckRequest(OCLExpression e, Set<Variable> variablesInScope, |
| OperationBodyToCallMapper operationBodyToCallMapper, UnusedEvaluationRequestFactory unusedEvaluationRequestFactory) { |
| UnusedEvaluationRequest result = null; |
| EObject container = e.eContainer(); |
| if (container instanceof IfExp && ((IfExp) container).getElseExpression() == e) { |
| result = unusedEvaluationRequestFactory.getUnusedEvaluationRequest((OCLExpression) ((IfExp) container).getCondition(), /* unused if */ true, null, |
| variablesInScope); |
| } |
| return result; |
| } |
| |
| private UnusedEvaluationRequest getThenClauseUnusedCheckRequest(OCLExpression e, Set<Variable> variablesInScope, |
| OperationBodyToCallMapper operationBodyToCallMapper, UnusedEvaluationRequestFactory unusedEvaluationRequestFactory) { |
| UnusedEvaluationRequest result = null; |
| EObject container = e.eContainer(); |
| if (container instanceof IfExp && ((IfExp) container).getThenExpression() == e) { |
| result = unusedEvaluationRequestFactory.getUnusedEvaluationRequest((OCLExpression) ((IfExp) container).getCondition(), /* unused if */ false, null, |
| variablesInScope); |
| } |
| return result; |
| } |
| |
| /** |
| * @return the expression for which this step is responsible |
| */ |
| public E getExpression() { |
| return expression; |
| } |
| |
| protected EClass getInnermostTypeConsideringTupleLiteralsLookedFor(Stack<String> tupleLiteralNamesToLookFor, EClassifier type) { |
| EClass result; |
| if (tupleLiteralNamesToLookFor == null || tupleLiteralNamesToLookFor.isEmpty()) { |
| result = getInnermostClass(type); |
| } else { |
| EClassifier currentType = getInnermostElementType(type); |
| int i=tupleLiteralNamesToLookFor.size()-1; |
| while (i>=0) { |
| TupleType tt = (TupleType) currentType; |
| EStructuralFeature part = tt.getEStructuralFeature(tupleLiteralNamesToLookFor.get(i)); |
| currentType = getInnermostClass(part.getEType()); |
| i--; |
| } |
| result = (EClass) currentType; |
| } |
| return result; |
| } |
| |
| public OperationCallExpKeyedSet traceback(AnnotatedEObject source, UnusedEvaluationRequestSet pendingUnusedEvalRequests, |
| org.eclipse.ocl.examples.impactanalyzer.instanceScope.traceback.TracebackCache tracebackCache, Notification changeEvent) { |
| tracebackExecutions++; |
| OperationCallExpKeyedSet result; |
| Pair<AnnotatedEObject, UnusedEvaluationRequestSet> key = new Pair<AnnotatedEObject, UnusedEvaluationRequestSet>(source, pendingUnusedEvalRequests); |
| if (isCurrentlyEvaluatingFor(key)) { |
| result = tracebackCache.getOperationCallExpKeyedSetFactory().emptySet(); |
| } else { |
| try { |
| startEvaluationFor(key); |
| result = tracebackCache.get(this, source, pendingUnusedEvalRequests); |
| if (result == null) { |
| if (requiredType != null && !requiredType.isInstance(source.getAnnotatedObject())) { |
| result = tracebackCache.getOperationCallExpKeyedSetFactory().emptySet(); |
| } else { |
| if (tracebackCache.getConfiguration().isUnusedDetectionActive()) { |
| // try to prove unusedness with the unused rules recorded for this step; if that fails, |
| // merge the unused evaluation requests that failed for unknown variables |
| // with the ones passed in pendingUnusedEvalRequests and carry on |
| UnusedEvaluationResult unusedEvaluationResult = UnusedEvaluationRequestSet.evaluate( |
| unusedEvaluationRequests, oppositeEndFinder, tracebackCache, oclFactory); |
| if (unusedEvaluationResult.hasProvenUnused()) { |
| provenUnused++; |
| result = tracebackCache.getOperationCallExpKeyedSetFactory().emptySet(); |
| } else { |
| result = performSubsequentTraceback(source, |
| unusedEvaluationResult.getNewRequestSet() == null ? null : unusedEvaluationResult |
| .getNewRequestSet().merge(pendingUnusedEvalRequests), tracebackCache, changeEvent); |
| } |
| } else { |
| result = performSubsequentTraceback(source, null, tracebackCache, changeEvent); |
| } |
| } |
| tracebackCache.put(this, source, pendingUnusedEvalRequests, result); |
| } |
| } finally { |
| finishedEvaluationFor(key); |
| } |
| } |
| return result; |
| } |
| |
| private boolean isCurrentlyEvaluatingFor(Pair<AnnotatedEObject, UnusedEvaluationRequestSet> key) { |
| return listOfKeysCurrentlyEvaluatingTracebackFor != null |
| ? listOfKeysCurrentlyEvaluatingTracebackFor.contains(key) |
| : key.equals(currentlyEvaluatingTracebackFor); |
| } |
| |
| private void finishedEvaluationFor(Pair<AnnotatedEObject, UnusedEvaluationRequestSet> key) { |
| if (listOfKeysCurrentlyEvaluatingTracebackFor != null) { |
| if (listOfKeysCurrentlyEvaluatingTracebackFor.size() == 1) { |
| listOfKeysCurrentlyEvaluatingTracebackFor = null; |
| } else { |
| listOfKeysCurrentlyEvaluatingTracebackFor.remove(key); |
| } |
| } else { |
| currentlyEvaluatingTracebackFor = null; |
| } |
| } |
| |
| private void startEvaluationFor(Pair<AnnotatedEObject, UnusedEvaluationRequestSet> key) { |
| if (listOfKeysCurrentlyEvaluatingTracebackFor != null) { |
| listOfKeysCurrentlyEvaluatingTracebackFor.add(key); |
| } else { |
| if (currentlyEvaluatingTracebackFor == null) { |
| currentlyEvaluatingTracebackFor = key; |
| } else { |
| listOfKeysCurrentlyEvaluatingTracebackFor = new ArrayList<Pair<AnnotatedEObject, UnusedEvaluationRequestSet>>(); |
| listOfKeysCurrentlyEvaluatingTracebackFor.add(currentlyEvaluatingTracebackFor); |
| currentlyEvaluatingTracebackFor = null; |
| listOfKeysCurrentlyEvaluatingTracebackFor.add(key); |
| } |
| } |
| } |
| |
| /** |
| * This method is used to invoke the {@link TracebackStep#traceback(AnnotatedEObject, UnusedEvaluationRequestSet, TracebackCache, Notification)} method on all necessary subsequent {@link TracebackStep}s and return their results. |
| * Which subsequent steps are necessary depends on the respective <code>source</code> {@link OCLExpression} the {@link TracebackStep} was created for. |
| */ |
| protected abstract OperationCallExpKeyedSet performSubsequentTraceback(AnnotatedEObject source, |
| UnusedEvaluationRequestSet pendingUnusedEvalRequests, org.eclipse.ocl.examples.impactanalyzer.instanceScope.traceback.TracebackCache tracebackCache, Notification changeEvent); |
| |
| |
| /** |
| * @return a new set that the caller therefore may modify at will without causing any harm |
| */ |
| private Set<Variable> getVariablesChangingScope(OCLExpression sourceExpression, OCLExpression targetExpression, |
| OperationBodyToCallMapper operationBodyToCallMapper) { |
| Set<Variable> result; |
| OCLExpression commonCompositionParent = commonCompositionParent(sourceExpression, targetExpression); |
| if (commonCompositionParent == null) { |
| result = new HashSet<Variable>(); |
| result.addAll(getAllVariablesInScope(sourceExpression, operationBodyToCallMapper)); |
| result.addAll(getAllVariablesInScope(targetExpression, operationBodyToCallMapper)); |
| } else { |
| result = variablesIntroducedBetween(sourceExpression, commonCompositionParent, operationBodyToCallMapper); |
| result.addAll(variablesIntroducedBetween(targetExpression, commonCompositionParent, operationBodyToCallMapper)); |
| } |
| return result; |
| } |
| |
| /** |
| * This method returns all variables introduced by <code>origin</code> or any of its containers, up to but excluding |
| * <code>parent</code>. For example, if <code>parent</code> is the <code>in</code>-expression of a {@link LetExp} in which a |
| * {@link LoopExp} is nested whose {@link LoopExp#getBody() body} contains <code>origin</code>, then the |
| * {@link LoopExp#getIterator() iterator variables} will be part of the result, but the <code>let</code>-variable to which the |
| * <code>in</code>-expression belongs will not be because it is immediately scoped by <code>parent</code>. |
| * |
| * @param origin |
| * The {@link OCLExpression} used as the origin of the search. |
| * @param parent |
| * The {@link OCLExpression} that is an immediate or transitive containment parent of the origin (see |
| * {@link EObject#eContainer()}). Variables immediately scoped by <code>parent</code> are included in the result. |
| * @return A {@link Set} of {@link OCLExpression}s containing all scope creating expressions in the containment hierarchy |
| * between origin and parent. The set returned is new and may be modified by the caller without causing any harm. |
| */ |
| private Set<Variable> variablesIntroducedBetween(OCLExpression origin, OCLExpression parent, |
| OperationBodyToCallMapper operationBodyToCallMapper) { |
| EObject e = origin; |
| Set<Variable> result = new HashSet<Variable>(); |
| while (e != null && e != parent) { |
| if (e instanceof OCLExpression) { |
| result.addAll(getVariablesScopedByExpression((OCLExpression) e, operationBodyToCallMapper)); |
| } |
| e = e.eContainer(); |
| } |
| return result; |
| } |
| |
| protected static Set<Variable> getVariablesScopedByExpression(OCLExpression e, OperationBodyToCallMapper operationBodyToCallMapper) { |
| EObject container = e.eContainer(); |
| Set<Variable> result = null; |
| if (container instanceof LoopExp && ((LoopExp) container).getBody() == e) { |
| // body of a loop expression |
| result = new HashSet<Variable>(); |
| for (org.eclipse.ocl.expressions.Variable<EClassifier, EParameter> v : ((LoopExp) container).getIterator()) { |
| result.add((Variable) v); |
| } |
| if (container instanceof IterateExp) { |
| Variable resultVariable = (Variable) ((IterateExp) container).getResult(); |
| if (resultVariable != null) { |
| result.add(resultVariable); |
| } |
| } |
| } else if (container instanceof LetExp && ((LetExp) container).getIn() == e) { |
| if (result == null) { |
| result = new HashSet<Variable>(); |
| } |
| // in-expression of a let-expression |
| result.add((Variable) ((LetExp) container).getVariable()); |
| } else { |
| Set<OperationCallExp> calls = operationBodyToCallMapper.getCallsOf(e); |
| if (!calls.isEmpty()) { |
| // body of an operation |
| result = addAll(result, operationBodyToCallMapper.getSelfVariablesUsedInBody(e)); |
| result = addAll(result, operationBodyToCallMapper.getParameterVariablesUsedInBody(e)); |
| } else if (e == OclHelper.getRootExpression(e)) { |
| result = addAll(result, operationBodyToCallMapper.getSelfVariablesUsedInBody(e)); |
| } |
| } |
| if (result == null) { |
| result = Collections.emptySet(); |
| } |
| return result; |
| } |
| |
| private static <T> Set<T> addAll(Set<T> to, Collection<T> what) { |
| if (to == null) { |
| to = new HashSet<T>(); |
| } |
| to.addAll(what); |
| return to; |
| } |
| |
| /** |
| * Starting from <code>e</code> and ascending its containment hierarchy, adds to the resulting set all variables that are scoped by |
| * any of the expressions visited. |
| * |
| * @return a new set that the client may modify at will without doing any harm |
| */ |
| protected static Set<Variable> getAllVariablesInScope(OCLExpression e, OperationBodyToCallMapper operationBodyToCallMapper) { |
| Set<Variable> result = new HashSet<Variable>(); |
| for (EObject cursor = e; cursor != null; cursor = cursor.eContainer()) { |
| if (cursor instanceof OCLExpression) { |
| result.addAll(getVariablesScopedByExpression((OCLExpression) cursor, operationBodyToCallMapper)); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * This method finds the common composition parent of the two given {@link OCLExpression}s. If the two expressions |
| * don't have a common container, <code>null</code> is returned. |
| * |
| * @param first The first {@link OCLExpression}. |
| * @param second The second {@link OCLExpression}. |
| * @return The common composition parent or null, in case there is none. |
| */ |
| private static OCLExpression commonCompositionParent(OCLExpression first, OCLExpression second) { |
| Set<OCLExpression> firstsContainersIncludingFirst = new HashSet<OCLExpression>(); |
| EObject firstsContainer = first; |
| while (firstsContainer != null && firstsContainer instanceof OCLExpression) { |
| firstsContainersIncludingFirst.add((OCLExpression) firstsContainer); |
| firstsContainer = firstsContainer.eContainer(); |
| } |
| EObject secondsContainer = second; |
| OCLExpression result = null; |
| while (result == null && secondsContainer != null && secondsContainer instanceof OCLExpression) { |
| if (firstsContainersIncludingFirst.contains(secondsContainer)) { |
| result = (OCLExpression) secondsContainer; |
| } else { |
| secondsContainer = secondsContainer.eContainer(); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Creates a new {@link TracebackStepAndScopeChange}} object. Fetches from the cache or produces the {@link TracebackStep}} |
| * and computes the variable scope changes (see {@link #getVariablesChangingScope(OCLExpression, OCLExpression, OperationBodyToCallMapper)}. |
| * The results of these two operations are used for the {@link TracebackStepAndScopeChange} constructor. |
| */ |
| protected TracebackStepAndScopeChange createTracebackStepAndScopeChange(OCLExpression sourceExpression, |
| OCLExpression targetExpression, EClass context, OperationBodyToCallMapper operationBodyToCallMapper, |
| Stack<String> tupleLiteralNamesToLookFor, TracebackStepCache tracebackStepCache) { |
| return new TracebackStepAndScopeChange(tracebackStepCache.getOrCreateNavigationPath(targetExpression, context, |
| operationBodyToCallMapper, tupleLiteralNamesToLookFor, oclFactory), getVariablesChangingScope(sourceExpression, |
| targetExpression, operationBodyToCallMapper)); |
| } |
| |
| /** |
| * Creates a new {@link TracebackStepAndScopeChange}} object, remembering an {@link OperationCallExp} to which the |
| * results produced by this step are specific. The results produced by the step returned will all be keyed |
| * by the <code>call</code>. Fetches from the cache or produces the {@link TracebackStep}} |
| * and computes the variable scope changes (see {@link #getVariablesChangingScope(OCLExpression, OCLExpression, OperationBodyToCallMapper)}. |
| * The results of these two operations are used for the {@link TracebackStepAndScopeChange} constructor. |
| */ |
| protected TracebackStepAndScopeChangeWithOperationCallExp createTracebackStepAndScopeChange(OCLExpression sourceExpression, |
| OCLExpression targetExpression, OperationCallExp call, EClass context, OperationBodyToCallMapper operationBodyToCallMapper, |
| Stack<String> tupleLiteralNamesToLookFor, TracebackStepCache tracebackStepCache) { |
| return new TracebackStepAndScopeChangeWithOperationCallExp(tracebackStepCache.getOrCreateNavigationPath(targetExpression, context, |
| operationBodyToCallMapper, tupleLiteralNamesToLookFor, oclFactory), getVariablesChangingScope(sourceExpression, |
| targetExpression, operationBodyToCallMapper), call); |
| } |
| |
| /** |
| * We assume a collection, possibly nested, that eventually has elements of a class-like type inside. If the innermost |
| * type is not an {@link EClass}, <code>null</code> is returned. |
| */ |
| protected EClass getInnermostClass(EClassifier type) { |
| EClass result = null; |
| while (!(type instanceof EClass) && type instanceof CollectionType) { |
| type = ((CollectionType) type).getElementType(); |
| } |
| if (type instanceof EClass) { |
| result = (EClass) type; |
| } |
| return result; |
| } |
| |
| /** |
| * We assume a collection, possibly nested, that eventually has elements of a class-like type inside. If the innermost |
| * type is not an {@link EClass}, <code>null</code> is returned. |
| */ |
| protected EClassifier getInnermostElementType(EClassifier type) { |
| while (!(type instanceof EClass) && type instanceof CollectionType) { |
| type = ((CollectionType) type).getElementType(); |
| } |
| return type; |
| } |
| |
| protected Stack<String> cloneWithTypeCheck(Stack<String> tupleLiteralNamesToLookFor) { |
| if (tupleLiteralNamesToLookFor == null) { |
| return null; |
| } |
| Object clone = tupleLiteralNamesToLookFor.clone(); |
| if (clone instanceof Stack<?>) { |
| @SuppressWarnings("unchecked") |
| Stack<String> newTupleStack = (Stack<String>) clone; |
| return newTupleStack; |
| } else { |
| throw new ClassCastException("Cloning an instance of Stack<String> didn't return an instance of the same type."); |
| } |
| } |
| |
| private String getAnnotation() { |
| return annotation; |
| } |
| |
| /** |
| * Constructs a human-readable description of the OCL expression used as debug info for this |
| * navigation step. This includes traveling up to the root expression in which the debug info |
| * expression is embedded. |
| */ |
| private String getVerboseDebugInfo(OperationBodyToCallMapper operationBodyToCallMapper) { |
| try { |
| if (AnnotatedEObject.IS_IN_DEBUG_MODE) { |
| StringBuilder result = new StringBuilder(); |
| result.append(" ==== "); |
| result.append(getClass().getSimpleName()); |
| result.append(" for expression ====\n "); |
| result.append(getExpression()); |
| OCLExpression root = OclHelper.getRootExpression(getExpression()); |
| if (root != getExpression()) { |
| result.append("\n ==== in expression =====\n"); |
| result.append(root.accept(HighlightingToStringVisitor.getInstance(root, getExpression()))); |
| } |
| Set<OperationCallExp> calls = operationBodyToCallMapper.getCallsOf(root); |
| result.append(!calls.isEmpty() ? "\n ===== which is the body of operation " |
| + formatOperation(calls.iterator().next().getReferredOperation()) + " =====" |
| : ""); |
| return result.toString(); |
| } else { |
| return AnnotatedEObject.NOT_IN_DEBUG_MODE_MESSAGE; |
| } |
| } catch (Exception e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| private String formatOperation(EOperation operation) { |
| StringBuilder result = new StringBuilder(((ENamedElement) operation.eContainer()).getName()); |
| result.append('.'); |
| result.append(operation.getName()); |
| result.append('('); |
| boolean first = true; |
| for (EParameter param : operation.getEParameters()) { |
| if (!first) { |
| result.append(", "); |
| } else { |
| first = false; |
| } |
| result.append(param.getName()); |
| result.append(':'); |
| result.append(param.getEType().getName()); |
| } |
| result.append(')'); |
| return result.toString(); |
| } |
| |
| /** |
| * Annotates a navigation from <code>fromObject</code> to <code>next</code> by taking over <code>fromObject</code>'s annotation, |
| * adding a description of this step and telling at which object the navigation arrived. In case we're not in |
| * {@link AnnotatedEObject#IS_IN_DEBUG_MODE debug mode}, a default message (see {@link AnnotatedEObject#NOT_IN_DEBUG_MODE_MESSAGE}) |
| * is used instead to save memory. |
| */ |
| protected AnnotatedEObject annotateEObject(AnnotatedEObject fromObject, |
| EObject next) { |
| if (AnnotatedEObject.IS_IN_DEBUG_MODE) { |
| return new AnnotatedEObject(next, fromObject, getAnnotation()); |
| } else { |
| return new AnnotatedEObject(next, AnnotatedEObject.NOT_IN_DEBUG_MODE_MESSAGE); |
| } |
| } |
| |
| /** |
| * Annotates a non-navigation where <code>object</code> is forwarded unchanged from this step to another. The result is an |
| * {@link AnnotatedEObject} with its from-object and reached object both being set to <code>object</code>, adding a |
| * description of this step and telling at which object the navigation arrived. In case we're not in |
| * {@link AnnotatedEObject#IS_IN_DEBUG_MODE debug mode}, a default message (see |
| * {@link AnnotatedEObject#NOT_IN_DEBUG_MODE_MESSAGE}) is used instead to save memory. |
| */ |
| protected AnnotatedEObject annotateEObject(AnnotatedEObject object) { |
| if (AnnotatedEObject.IS_IN_DEBUG_MODE) { |
| return new AnnotatedEObject(object.getAnnotatedObject(), object, getAnnotation()); |
| } else { |
| return object; |
| } |
| } |
| |
| /** |
| * If in {@link AnnotatedEObject#IS_IN_DEBUG_MODE debug mode}, creates a new {@link AnnotatedEObject} for each |
| * one in <code>newResults</code>, assuming that there is no "from" object; as an alibi "from" object, the |
| * annotated objects from <code>newResults</code> are used. |
| */ |
| protected Set<AnnotatedEObject> annotate(AnnotatedEObject fromObject, Set<AnnotatedEObject> newResults) { |
| if (AnnotatedEObject.IS_IN_DEBUG_MODE) { |
| Set<AnnotatedEObject> result = new HashSet<AnnotatedEObject>(); |
| for (AnnotatedEObject newResult : newResults) { |
| result.add(new AnnotatedEObject(newResult.getAnnotatedObject(), fromObject, getAnnotation())); |
| } |
| return result; |
| } else { |
| return newResults; |
| } |
| } |
| |
| protected OppositeEndFinder getOppositeEndFinder() { |
| return oppositeEndFinder; |
| } |
| |
| } |
