| /******************************************************************************* |
| * Copyright (c) 2016, 2017 Willink Transformations and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * E.D.Willink - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.qvtd.compiler.internal.qvtr2qvtc; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| 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.Element; |
| import org.eclipse.ocl.pivot.IteratorVariable; |
| import org.eclipse.ocl.pivot.LetVariable; |
| import org.eclipse.ocl.pivot.NavigationCallExp; |
| import org.eclipse.ocl.pivot.OCLExpression; |
| import org.eclipse.ocl.pivot.OperationCallExp; |
| import org.eclipse.ocl.pivot.Parameter; |
| import org.eclipse.ocl.pivot.Property; |
| import org.eclipse.ocl.pivot.Type; |
| import org.eclipse.ocl.pivot.Variable; |
| import org.eclipse.ocl.pivot.VariableDeclaration; |
| import org.eclipse.ocl.pivot.VariableExp; |
| import org.eclipse.ocl.pivot.utilities.ClassUtil; |
| import org.eclipse.ocl.pivot.utilities.TreeIterable; |
| import org.eclipse.qvtd.compiler.CompilerChainException; |
| import org.eclipse.qvtd.compiler.internal.qvtr2qvtc.analysis.RelationAnalysis; |
| import org.eclipse.qvtd.compiler.internal.qvtr2qvtc.analysis.TransformationAnalysis; |
| import org.eclipse.qvtd.compiler.internal.qvtr2qvtc.analysis.VariablesAnalysis; |
| import org.eclipse.qvtd.compiler.internal.qvtr2qvtc.trace.RelationalTransformation2TracePackage; |
| import org.eclipse.qvtd.pivot.qvtbase.Predicate; |
| import org.eclipse.qvtd.pivot.qvtbase.Transformation; |
| import org.eclipse.qvtd.pivot.qvtbase.TypedModel; |
| 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.CoreDomain; |
| import org.eclipse.qvtd.pivot.qvtcore.CorePattern; |
| import org.eclipse.qvtd.pivot.qvtcore.GuardPattern; |
| import org.eclipse.qvtd.pivot.qvtcore.Mapping; |
| import org.eclipse.qvtd.pivot.qvtcore.NavigationAssignment; |
| import org.eclipse.qvtd.pivot.qvtcore.RealizedVariable; |
| import org.eclipse.qvtd.pivot.qvtcore.utilities.QVTcoreUtil; |
| import org.eclipse.qvtd.pivot.qvtrelation.Relation; |
| import org.eclipse.qvtd.pivot.qvtrelation.RelationCallExp; |
| import org.eclipse.qvtd.pivot.qvtrelation.RelationDomain; |
| import org.eclipse.qvtd.pivot.qvtrelation.RelationalTransformation; |
| import org.eclipse.qvtd.pivot.qvtrelation.utilities.QVTrelationUtil; |
| import org.eclipse.qvtd.pivot.qvttemplate.CollectionTemplateExp; |
| import org.eclipse.qvtd.pivot.qvttemplate.ObjectTemplateExp; |
| import org.eclipse.qvtd.pivot.qvttemplate.PropertyTemplateItem; |
| import org.eclipse.qvtd.pivot.qvttemplate.TemplateExp; |
| |
| /** |
| * VariablesAnalysis manages all the variables in use by a Relation and its corresponding Mapping. |
| */ |
| /*public*/ class Variables2Variables extends VariablesAnalysis |
| { |
| // public static void gatherBoundVariables(@NonNull Map<@NonNull Variable, @Nullable TemplateExp> boundVariables, @NonNull Iterable<@NonNull ? extends Element> asRoots) { |
| // for (Element asRoot : asRoots) { |
| // gatherBoundVariables(boundVariables, asRoot); |
| // } |
| // } |
| /** |
| * Return a Map from each bound variable to the TemplateExp for which it is the TempateExp.getBindsTo(). |
| */ |
| public static @NonNull Map<@NonNull Variable, @NonNull TemplateExp> gatherBoundVariables(@NonNull Element asRoot) { |
| Map<@NonNull Variable, @NonNull TemplateExp> boundVariables = new HashMap<>(); |
| for (EObject eObject : new TreeIterable(asRoot, true)) { |
| if (eObject instanceof TemplateExp) { |
| Variable bindsTo = QVTrelationUtil.getBindsTo((TemplateExp)eObject); |
| TemplateExp oldTemplateExp = boundVariables.put(bindsTo, (TemplateExp)eObject); |
| assert oldTemplateExp == null; |
| } |
| } |
| return boundVariables; |
| } |
| |
| /** |
| * Return a Map from each member variable to the CollectionTemplateExp's for which it is a CollectionTempateExp.member.referredVariable. |
| */ |
| public static @Nullable Map<@NonNull Variable, @NonNull List<@NonNull CollectionTemplateExp>> gatherMemberVariables(@NonNull Element asRoot) { |
| Map<@NonNull Variable, @NonNull List<@NonNull CollectionTemplateExp>> memberVariable2collectionTemplateExps = null; |
| for (EObject eObject : new TreeIterable(asRoot, true)) { |
| if (eObject instanceof CollectionTemplateExp) { |
| CollectionTemplateExp collectionTemplateExp = (CollectionTemplateExp)eObject; |
| for (@NonNull OCLExpression member : QVTrelationUtil.getOwnedMembers(collectionTemplateExp)) { |
| if (member instanceof VariableExp) { |
| Variable memberVariable = QVTrelationUtil.getReferredVariable((VariableExp)member); |
| if (memberVariable2collectionTemplateExps == null) { |
| memberVariable2collectionTemplateExps = new HashMap<>(); |
| } |
| List<@NonNull CollectionTemplateExp> collectionTemplateExps = memberVariable2collectionTemplateExps.get(memberVariable); |
| if (collectionTemplateExps == null) { |
| collectionTemplateExps = new ArrayList<>(); |
| memberVariable2collectionTemplateExps.put(memberVariable, collectionTemplateExps); |
| } |
| if (!collectionTemplateExps.contains(collectionTemplateExp)) { |
| collectionTemplateExps.add(collectionTemplateExp); |
| } |
| } |
| } |
| } |
| } |
| return memberVariable2collectionTemplateExps; |
| } |
| |
| /** |
| * Return all variables referenced within the composition tree of each of asRoots. |
| */ |
| public static void gatherReferredVariables(@NonNull Set<@NonNull Variable> referredVariables, @NonNull Iterable<@NonNull ? extends Element> asRoots) { |
| for (@NonNull Element asRoot : asRoots) { |
| gatherReferredVariables(referredVariables, asRoot); |
| } |
| } |
| public static void gatherReferredVariables(@NonNull Set<@NonNull Variable> referredVariables, @NonNull Element asRoot) { |
| for (@NonNull EObject eObject : new TreeIterable(asRoot, true)) { |
| if (eObject instanceof VariableExp) { |
| VariableDeclaration referredVariable = ((VariableExp)eObject).getReferredVariable(); |
| if (referredVariable instanceof Variable) { |
| referredVariables.add((Variable)referredVariable); |
| } |
| } |
| else if (eObject instanceof Variable) { |
| referredVariables.add((Variable)eObject); |
| } |
| else if (eObject instanceof TemplateExp) { |
| Variable bindsTo = ((TemplateExp)eObject).getBindsTo(); |
| if (bindsTo != null) { |
| referredVariables.add(bindsTo); |
| } |
| if (eObject instanceof CollectionTemplateExp) { // Member variable are contained VariableExp's |
| Variable rest = ((CollectionTemplateExp)eObject).getRest(); |
| if ((rest != null) && !rest.isIsImplicit()) { |
| referredVariables.add(rest); |
| } |
| } |
| } |
| } |
| } |
| public static void gatherReferredVariablesWithTypedModels(@NonNull Map<@NonNull Variable, @Nullable TypedModel> referredVariable2typedModel, @NonNull Element asRoot) { |
| for (EObject eObject : new TreeIterable(asRoot, true)) { |
| if (eObject instanceof VariableExp) { |
| VariableDeclaration referredVariable = ((VariableExp)eObject).getReferredVariable(); |
| if (referredVariable instanceof Variable) { |
| EObject eContainer = eObject.eContainer(); |
| if (eContainer instanceof RelationCallExp) { |
| RelationCallExp relationCallExp = (RelationCallExp)eContainer; |
| int argument = relationCallExp.getArgument().indexOf(eObject); |
| assert argument >= 0; |
| Relation referredRelation = ClassUtil.nonNullState(relationCallExp.getReferredRelation()); |
| List<@NonNull Variable> rootVariables = QVTrelationUtil.getRootVariables(referredRelation); |
| assert argument < rootVariables.size(); |
| Variable rootVariable = rootVariables.get(argument); |
| RelationDomain relationDomain = QVTrelationUtil.getRootVariableDomain(rootVariable); |
| gatherReferredVariablesWithTypedModelsAdd(referredVariable2typedModel, (Variable)referredVariable, relationDomain.getTypedModel()); |
| } |
| else { |
| gatherReferredVariablesWithTypedModelsAdd(referredVariable2typedModel, (Variable)referredVariable, null); |
| } |
| } |
| } |
| else if (eObject instanceof Variable) { |
| gatherReferredVariablesWithTypedModelsAdd(referredVariable2typedModel, (Variable)eObject, null); |
| } |
| else if (eObject instanceof TemplateExp) { |
| Variable bindsTo = ((TemplateExp)eObject).getBindsTo(); |
| if (bindsTo != null) { |
| gatherReferredVariablesWithTypedModelsAdd(referredVariable2typedModel, bindsTo, null); |
| } |
| if (eObject instanceof CollectionTemplateExp) { |
| Variable rest = ((CollectionTemplateExp)eObject).getRest(); |
| if ((rest != null) && !rest.isIsImplicit()) { |
| gatherReferredVariablesWithTypedModelsAdd(referredVariable2typedModel, rest, null); |
| } |
| } |
| } |
| } |
| } |
| private static void gatherReferredVariablesWithTypedModelsAdd(@NonNull Map<@NonNull Variable, @Nullable TypedModel> referredVariable2typedModel, |
| @NonNull Variable variable, @Nullable TypedModel rTypedModel) { |
| if (rTypedModel != null) { |
| TypedModel oldTypedModel = referredVariable2typedModel.put(variable, rTypedModel); |
| assert (oldTypedModel == rTypedModel) || (oldTypedModel == null); |
| } |
| else if (!referredVariable2typedModel.containsKey(variable)) { |
| referredVariable2typedModel.put(variable, null); |
| } |
| } |
| |
| /** |
| * Return a Map from each rest variable to the CollectionTemplateExp for which it is a CollectionTempateExp.rest. |
| */ |
| public static @Nullable Map<@NonNull Variable, @NonNull CollectionTemplateExp> gatherRestVariables(@NonNull Element asRoot) { |
| Map<@NonNull Variable, @NonNull CollectionTemplateExp> restVariable2collectionTemplateExp = null; |
| for (EObject eObject : new TreeIterable(asRoot, true)) { |
| if (eObject instanceof CollectionTemplateExp) { |
| CollectionTemplateExp collectionTemplateExp = (CollectionTemplateExp)eObject; |
| Variable rest = collectionTemplateExp.getRest(); |
| if (rest != null) { |
| if (restVariable2collectionTemplateExp == null) { |
| restVariable2collectionTemplateExp = new HashMap<>(); |
| } |
| CollectionTemplateExp oldCollectionTemplateExp = restVariable2collectionTemplateExp.put(rest, collectionTemplateExp); |
| assert oldCollectionTemplateExp == null; |
| } |
| } |
| } |
| return restVariable2collectionTemplateExp; |
| } |
| |
| // TODO bug 453863 // ?? this is suspect for more than 2 domains. // FIXME What is 'shared'? a) any two domains b) output/any-input c) all domains |
| /** |
| * Return the variables that are used by more than one domain of the relation and so must be middle variables. |
| */ |
| public static @NonNull Set<@NonNull Variable> getMiddleDomainVariables(@NonNull Relation rRelation) { |
| Set<@NonNull Variable> rSomeDomainVariables = new HashSet<>(); |
| Set<@NonNull Variable> rMiddleDomainVariables = new HashSet<>(); |
| for (@NonNull RelationDomain rDomain : QVTrelationUtil.getOwnedDomains(rRelation)) { |
| Set<@NonNull Variable> rThisDomainVariables = new HashSet<>(); |
| Variables2Variables.gatherReferredVariables(rThisDomainVariables, rDomain); |
| for (@NonNull Variable rVariable : rThisDomainVariables) { |
| if (!rSomeDomainVariables.add(rVariable)) { |
| rMiddleDomainVariables.add(rVariable); // Accumulate second (and higher) usages |
| } |
| } |
| } |
| return rMiddleDomainVariables; |
| } |
| |
| // protected final @NonNull QVTr2QVTc qvtr2qvtc; |
| protected final @NonNull RelationalTransformation2TracePackage relationalTransformation2tracePackage; |
| protected final @NonNull CoreDomain cEnforcedDomain; |
| protected final @NonNull Mapping cMapping; |
| protected final @NonNull Transformation cTransformation; |
| protected final @NonNull BottomPattern cMiddleBottomPattern; |
| protected final @NonNull GuardPattern cMiddleGuardPattern; |
| protected final @Nullable VariableDeclaration cMiddleVariable; // tcv: The trace class variable (the middle variable identifying the middle object) |
| protected final @NonNull Variable rThisVariable; |
| protected final @NonNull Variable cThisVariable; |
| |
| /** |
| * Map from the each core variable name in use to an originating object, typically the VariableAnalysis of a relation variable, |
| * but the RelationCallExp of a where, the invoking relation of a call-from invocation, or this for the middle variable. |
| */ |
| private @NonNull Map<@NonNull String, @NonNull Variable2Variable> name2originator = new HashMap<>(); |
| |
| /** |
| * The analysis of each relation variable. |
| */ |
| private final @NonNull Map<@NonNull VariableDeclaration, @NonNull Variable2Variable> rVariable2analysis = new HashMap<>(); |
| |
| /** |
| * The analysis of each core variable. |
| */ |
| private final @NonNull Map<@NonNull VariableDeclaration, @NonNull Variable2Variable> cVariable2analysis = new HashMap<>(); |
| |
| public Variables2Variables(@NonNull RelationAnalysis relationAnalysis, @NonNull RelationDomain rEnforcedDomain, |
| @NonNull CoreDomain cEnforcedDomain, @Nullable Type traceClass, boolean isWhened, boolean isWhered) throws CompilerChainException { |
| super(relationAnalysis, isWhened, isWhered); |
| TransformationAnalysis transformationAnalysis = relationAnalysis.getTransformationAnalysis(); |
| QVTr2QVTc qvtr2qvtc = transformationAnalysis.getQVTr2QVTc(); |
| this.relationalTransformation2tracePackage = qvtr2qvtc.getRelationalTransformation2TracePackage(transformationAnalysis); |
| this.cEnforcedDomain = cEnforcedDomain; |
| this.cMapping = ClassUtil.nonNullState(QVTcoreUtil.getContainingMapping(cEnforcedDomain)); |
| this.cTransformation = ClassUtil.nonNullState(cMapping.getTransformation()); |
| this.cMiddleBottomPattern = ClassUtil.nonNullState(cMapping.getBottomPattern()); |
| this.cMiddleGuardPattern = ClassUtil.nonNullState(cMapping.getGuardPattern()); |
| // |
| this.cMiddleVariable = (traceClass != null) ? relationAnalysis.traceIsRealized() ? addCoreRealizedVariable("trace", traceClass) : addCoreGuardVariable("trace", traceClass) : null; |
| |
| this.rThisVariable = QVTbaseUtil.getContextVariable(environmentFactory.getStandardLibrary(), QVTbaseUtil.getContainingTransformation(rEnforcedDomain)); |
| this.cThisVariable = QVTbaseUtil.getContextVariable(environmentFactory.getStandardLibrary(), cTransformation); |
| ThisVariable2Variable thisVariableAnalysis = new ThisVariable2Variable(this, rThisVariable, cThisVariable); |
| addVariableAnalysis(thisVariableAnalysis); |
| } |
| |
| /** |
| * Add the predicate "cLeftExpression = cRightExpression" to cCorePattern. |
| * @throws CompilerChainException |
| */ |
| protected void addConditionPredicate(@NonNull CorePattern cCorePattern, @NonNull OCLExpression cLeftExpression, @NonNull OCLExpression cRightExpression) throws CompilerChainException { |
| OperationCallExp eTerm = createOperationCallExp(cLeftExpression, "=", cRightExpression); |
| addPredicate(cCorePattern, eTerm); |
| } |
| |
| /** |
| * Create a core Variable with a name and type in the middle guard pattern. The variable has no corresponding relation variable. |
| * @throws CompilerChainException |
| */ |
| public @NonNull Variable addCoreGuardVariable(@NonNull String name, @NonNull Type type) throws CompilerChainException { |
| CoreVariable2Variable analysis = new CoreVariable2Variable(this, name, type, null); |
| Variable cVariable = analysis.getCoreVariable(); |
| addVariableAnalysis(analysis); |
| cMiddleGuardPattern.getVariable().add(cVariable); |
| return cVariable; |
| } |
| |
| /** |
| * Create a core RealizedVariable with a name and type in the middle bottom pattern. The variable has no corresponding relation variable. |
| * @throws CompilerChainException |
| */ |
| public @NonNull RealizedVariable addCoreRealizedVariable(@NonNull String name, @NonNull Type type) throws CompilerChainException { |
| CoreVariable2Variable analysis = new CoreVariable2Variable(this, name, type); |
| RealizedVariable cVariable = analysis.getCoreRealizedVariable(); |
| addVariableAnalysis(analysis); |
| cMiddleBottomPattern.getRealizedVariable().add(cVariable); |
| return cVariable; |
| } |
| |
| public @NonNull Variable addCoreVariable(@NonNull String name, @NonNull OCLExpression mMember) throws CompilerChainException { |
| CoreVariable2Variable analysis = new CoreVariable2Variable(this, name, ClassUtil.nonNullState(mMember.getType()), mMember); |
| Variable cVariable = analysis.getCoreVariable(); |
| addVariableAnalysis(analysis); |
| cMiddleGuardPattern.getVariable().add(cVariable); |
| return cVariable; |
| } |
| |
| public void addNavigationAssignment(@NonNull Variable rTargetVariable, @NonNull Property targetProperty, @NonNull OCLExpression cExpression, @Nullable Boolean isPartial) throws CompilerChainException { |
| getVariableAnalysis(rTargetVariable).addNavigationAssignment(targetProperty, cExpression, isPartial); |
| } |
| |
| public void addNavigationPredicate(@NonNull CorePattern cCorePattern, @NonNull Variable rTargetVariable, @NonNull Property targetProperty, @NonNull OCLExpression cExpression) throws CompilerChainException { |
| Variable cTargetVariable = getCoreVariable(rTargetVariable); |
| NavigationCallExp cNavigationExp = createNavigationCallExp(createVariableExp(cTargetVariable), targetProperty); |
| if (cExpression instanceof VariableExp) { |
| addConditionPredicate(cCorePattern, cExpression, cNavigationExp); |
| } |
| else { |
| addConditionPredicate(cCorePattern, cNavigationExp, cExpression); |
| } |
| } |
| |
| protected void addPredicate(@NonNull CorePattern cExpectedCorePattern, @NonNull OCLExpression cExpression) throws CompilerChainException { |
| assert cMapping == QVTcoreUtil.getContainingMapping(cExpectedCorePattern); |
| QVTr2QVTc.SYNTHESIS.println(" addPredicate " + cExpression); |
| Set<@NonNull Variable> cReferredVariables = new HashSet<>(); |
| gatherReferredVariables(cReferredVariables, cExpression); |
| boolean isGuard = true; |
| boolean isMiddle = false; |
| CorePattern cReferredPattern = null; |
| for (@NonNull Variable cReferredVariable : cReferredVariables) { |
| Variable2Variable analysis = cVariable2analysis.get(cReferredVariable); |
| if (analysis == null) { |
| isGuard = false; |
| isMiddle = true; |
| break; |
| } |
| else { |
| CorePattern corePattern = analysis.getCorePattern(); |
| if (corePattern == null) { |
| } |
| else if (!(corePattern instanceof GuardPattern)) { |
| isGuard = false; |
| } |
| if (cReferredPattern == null) { |
| cReferredPattern = corePattern; |
| } |
| else if (cReferredPattern != corePattern) { |
| isMiddle = true; |
| } |
| } |
| } |
| if (isMiddle) { |
| cReferredPattern = isGuard ? cMiddleGuardPattern : cMiddleBottomPattern; |
| } |
| else if (cReferredPattern != null) { |
| cReferredPattern = isGuard ? cReferredPattern.getArea().getGuardPattern() : cReferredPattern.getArea().getBottomPattern(); |
| } |
| // assert cExpectedCorePattern == cReferredPattern; |
| if (cReferredPattern != null) { |
| Predicate cPredicate = createPredicate(cExpression); |
| /*cExpectedCorePattern*/cReferredPattern.getPredicate().add(cPredicate); |
| } |
| } |
| |
| /** |
| * Add the assignment for rVariable to the middle BottomPattern. If isOptional, a missing trace property is ignored. |
| * |
| * Returns the core variant of the relation variable. |
| */ |
| public @NonNull Variable addTraceNavigationAssignment(@NonNull Variable rVariable, boolean isOptional) throws CompilerChainException { |
| @SuppressWarnings("unused") |
| boolean traceIsRealized = getRelationAnalysis().traceIsRealized(); |
| // assert traceIsRealized; |
| VariableDeclaration cMiddleRealizedVariable2 = getMiddleVariable(); |
| Variable cVariable = getCoreVariable(rVariable); //getCoreRealizedVariable(rTargetVariable); |
| Property cTargetProperty = relationalTransformation2tracePackage.basicGetTraceProperty(QVTrelationUtil.getType(cMiddleRealizedVariable2), rVariable); |
| if (!isOptional && (cTargetProperty == null)) { // FIXME debugging |
| cTargetProperty = relationalTransformation2tracePackage.basicGetTraceProperty(QVTrelationUtil.getType(cMiddleRealizedVariable2), rVariable); |
| } |
| assert isOptional || (cTargetProperty != null); |
| if (cTargetProperty != null) { |
| assert (!cTargetProperty.isIsMany() || (cVariable.getType() instanceof CollectionType)); |
| VariableExp cSlotVariableExp = createVariableExp(cMiddleRealizedVariable2); |
| OCLExpression cExpression = createVariableExp(cVariable); |
| NavigationAssignment cAssignment = createNavigationAssignment(cSlotVariableExp, cTargetProperty, cExpression, false); |
| QVTr2QVTc.SYNTHESIS.println(" addPropertyAssignment " + cAssignment); |
| assertNewAssignment(QVTcoreUtil.getOwnedAssignments(cMiddleBottomPattern), cAssignment); |
| cMiddleBottomPattern.getAssignment().add(cAssignment); |
| } |
| return cVariable; |
| } |
| |
| public @NonNull Variable addTraceNavigationAssignment(@NonNull Property cTargetProperty, @NonNull Variable cVariable) throws CompilerChainException { |
| @SuppressWarnings("unused") |
| boolean traceIsRealized = getRelationAnalysis().traceIsRealized(); |
| // assert traceIsRealized; |
| assert (!cTargetProperty.isIsMany() || (cVariable.getType() instanceof CollectionType)); |
| VariableDeclaration cMiddleRealizedVariable2 = getMiddleVariable(); |
| VariableExp cSlotVariableExp = createVariableExp(cMiddleRealizedVariable2); |
| OCLExpression cExpression = createVariableExp(cVariable); |
| NavigationAssignment cAssignment = createNavigationAssignment(cSlotVariableExp, cTargetProperty, cExpression, false); |
| QVTr2QVTc.SYNTHESIS.println(" addPropertyAssignment " + cAssignment); |
| assertNewAssignment(QVTcoreUtil.getOwnedAssignments(cMiddleBottomPattern), cAssignment); |
| cMiddleBottomPattern.getAssignment().add(cAssignment); |
| return cVariable; |
| } |
| |
| /** |
| * Add a predicate for rVariable wrt its trace in the middle GuardPattern. |
| * |
| * Returns the core variant of the relation variable. |
| */ |
| public @NonNull Variable addTraceNavigationPredicate(@NonNull Variable rVariable) throws CompilerChainException { |
| VariableDeclaration cMiddleRealizedVariable2 = getMiddleVariable(); |
| Variable cVariable = getCoreVariable(rVariable); //getCoreRealizedVariable(rTargetVariable); |
| Property cTargetProperty = relationalTransformation2tracePackage.basicGetTraceProperty(QVTrelationUtil.getType(cMiddleRealizedVariable2), rVariable); |
| assert cTargetProperty != null; |
| assert (!cTargetProperty.isIsMany() || (cVariable.getType() instanceof CollectionType)); |
| VariableExp cSlotVariableExp = createVariableExp(cMiddleRealizedVariable2); |
| OCLExpression cRightExp = createVariableExp(cVariable); |
| NavigationCallExp cLeftExp = createNavigationCallExp(cSlotVariableExp, cTargetProperty); |
| // QVTr2QVTc.SYNTHESIS.println(" addPropertyAssignment " + cAssignment); |
| addConditionPredicate(cMiddleGuardPattern, cLeftExp, cRightExp); |
| return cVariable; |
| } |
| |
| public void addVariableAnalysis(@NonNull Variable2Variable analysis) { |
| Variable cVariable = analysis.getCoreVariable(); |
| cVariable2analysis.put(cVariable, analysis); |
| VariableDeclaration rVariable = analysis.getRelationVariable(); |
| if (rVariable != null) { |
| rVariable2analysis.put(rVariable, analysis); |
| } |
| } |
| |
| public void assertNewAssignment(@NonNull Iterable<@NonNull Assignment> oldAssignments, @NonNull NavigationAssignment newAssignment) { |
| // if ("tr.action := sm".equals(newAssignment.toString())) { |
| // newAssignment.toString(); |
| // } |
| OCLExpression newSlotExpression = newAssignment.getSlotExpression(); |
| if (newSlotExpression instanceof VariableExp) { |
| VariableDeclaration newVariable = ((VariableExp)newSlotExpression).getReferredVariable(); |
| Property targetProperty = QVTcoreUtil.getTargetProperty(newAssignment); |
| for (@NonNull Assignment oldAssignment : oldAssignments) { |
| if (oldAssignment instanceof NavigationAssignment) { |
| if (QVTcoreUtil.getTargetProperty((NavigationAssignment)oldAssignment) == targetProperty) { |
| OCLExpression oldSlotExpression = ((NavigationAssignment)oldAssignment).getSlotExpression(); |
| if (oldSlotExpression instanceof VariableExp) { |
| VariableDeclaration oldVariable = ((VariableExp)oldSlotExpression).getReferredVariable(); |
| assert oldVariable != newVariable : "Repeated assignment: \"" + oldAssignment + "\", \"" + newAssignment + "\""; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| protected @Nullable Variable2Variable basicGetVariableAnalysis(@NonNull Variable relationVariable) { |
| return rVariable2analysis.get(relationVariable); |
| } |
| |
| public void check() { |
| for (@NonNull Variable2Variable analysis : rVariable2analysis.values()) { |
| analysis.check(); |
| } |
| } |
| |
| public @NonNull Iterable<@NonNull Variable2Variable> getAnalyses() { |
| return rVariable2analysis.values(); |
| } |
| |
| public @NonNull CoreDomain getCoreDomain(@NonNull TypedModel rTypedModel) { |
| TypedModel cTypedModel = relationAnalysis.getTransformationAnalysis().getQVTr2QVTc().getCoreTypedModel(rTypedModel); |
| return QVTcoreUtil.getDomain(cMapping, cTypedModel); |
| } |
| |
| public @NonNull Variable getCoreThisVariable() { |
| return cThisVariable; |
| } |
| |
| public @NonNull Variable getCoreVariable(@NonNull Variable rVariable) { // doRVarToMVar |
| return getVariableAnalysis(rVariable).getCoreVariable(); |
| } |
| |
| protected @NonNull Variable2Variable getCoreVariableAnalysis(@NonNull VariableDeclaration coreVariable) { |
| return ClassUtil.nonNullState(cVariable2analysis.get(coreVariable)); |
| } |
| |
| public @NonNull BottomPattern getMiddleBottomPattern() { |
| return cMiddleBottomPattern; |
| } |
| |
| public @NonNull GuardPattern getMiddleGuardPattern() { |
| return cMiddleGuardPattern; |
| } |
| |
| public @NonNull VariableDeclaration getMiddleVariable() { |
| return ClassUtil.nonNullState(cMiddleVariable); |
| } |
| |
| public @NonNull RelationAnalysis getRelationAnalysis() { |
| return relationAnalysis; |
| } |
| |
| @Nullable OCLExpression getTemplateExp(@NonNull ObjectTemplateExp objectTemplateExp, @NonNull Parameter keyParameter) { |
| String keyParameterName = keyParameter.getName(); |
| for (@NonNull PropertyTemplateItem propertyTemplateItem : ClassUtil.nullFree(objectTemplateExp.getPart())) { |
| Property property = propertyTemplateItem.getReferredProperty(); |
| if (ClassUtil.safeEquals(property.getName(), keyParameterName)) { |
| return propertyTemplateItem.getValue(); |
| } |
| } |
| EObject eContainer = objectTemplateExp.eContainer(); |
| if (eContainer instanceof PropertyTemplateItem) { |
| PropertyTemplateItem containingPropertyTemplateItem = (PropertyTemplateItem)eContainer; |
| Property property = containingPropertyTemplateItem.getReferredProperty(); |
| Property oppositeProperty = property != null ? property.getOpposite() : null; |
| if ((oppositeProperty != null) && ClassUtil.safeEquals(oppositeProperty.getName(), keyParameterName)) { |
| return containingPropertyTemplateItem.getObjContainer(); |
| } |
| } |
| return null; |
| } |
| |
| public @NonNull String getUniqueVariableName(@NonNull String name, @NonNull Variable2Variable originator) { |
| Object oldOriginator = name2originator.get(name); |
| if (oldOriginator != null) { |
| assert oldOriginator != originator; // Lazy re-creation should not occur. |
| for (int i = 0; true; i++) { |
| String newName = name + "_" + i; |
| if (!name2originator.containsKey(newName)) { |
| name = newName; |
| break; |
| } |
| } |
| } |
| name2originator.put(name, originator); |
| return name; |
| } |
| |
| protected @NonNull Variable2Variable getVariableAnalysis(@NonNull Variable relationVariable) { |
| Variable2Variable analysis = rVariable2analysis.get(relationVariable); |
| if (analysis == null) { |
| assert QVTbaseUtil.basicGetContainingTransformation(relationVariable) instanceof RelationalTransformation; |
| if (relationVariable instanceof IteratorVariable) { |
| analysis = new IteratorVariable2Variable(this, (IteratorVariable)relationVariable); |
| } |
| else if (relationVariable instanceof LetVariable) { |
| analysis = new LetVariable2Variable(this, (LetVariable)relationVariable); |
| } |
| else { |
| analysis = new RelationVariable2Variable(this, relationVariable); |
| } |
| rVariable2analysis.put(relationVariable, analysis); |
| } |
| return analysis; |
| } |
| |
| public boolean isAbstract() { |
| return relationAnalysis.getRelation().isIsAbstract(); |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder s = new StringBuilder(); |
| List<@NonNull String> names = new ArrayList<>(name2originator.keySet()); |
| Collections.sort(names); |
| for (@NonNull String name : names) { |
| if (s.length() > 0) { |
| s.append("\n"); |
| } |
| s.append(name + " => " ); |
| Object originator = name2originator.get(name); |
| if (originator != this) { |
| s.append(originator); |
| } |
| } |
| return s.toString(); |
| } |
| } |
