path: root/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtu2qvtm/QVTu2QVTm.java

/*******************************************************************************
 * Copyright (c) 2016 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:
 *     Horacio Hoyos - initial research
 *     E.D.Willink - initial API and implementation based on MtcBroker
 ******************************************************************************/
package org.eclipse.qvtd.compiler.internal.qvtu2qvtm;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.ocl.pivot.CompleteClass;
import org.eclipse.ocl.pivot.Element;
import org.eclipse.ocl.pivot.OCLExpression;
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.EnvironmentFactory;
import org.eclipse.ocl.pivot.utilities.PivotUtil;
import org.eclipse.qvtd.compiler.internal.common.AbstractQVTc2QVTc;
import org.eclipse.qvtd.pivot.qvtbase.Domain;
import org.eclipse.qvtd.pivot.qvtbase.Predicate;
import org.eclipse.qvtd.pivot.qvtbase.QVTbaseFactory;
import org.eclipse.qvtd.pivot.qvtbase.Rule;
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.Area;
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.CoreModel;
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.QVTcoreFactory;
import org.eclipse.qvtd.pivot.qvtcore.RealizedVariable;
import org.eclipse.qvtd.pivot.qvtcore.VariableAssignment;
import org.eclipse.qvtd.pivot.qvtcore.utilities.QVTcoreUtil;
import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleConstants;
import org.eclipse.qvtd.pivot.qvtschedule.utilities.SymbolNameBuilder;
import org.eclipse.qvtd.pivot.qvtschedule.utilities.SymbolNameReservation;

import com.google.common.collect.Iterables;

/**
 * QVTu2QVTm simplifies a QVTu transformation
 * - flattening nested mappings
 * - flattening mapping refinements
 */
public class QVTu2QVTm extends AbstractQVTc2QVTc
{
	protected static class CreateVisitor extends AbstractCreateVisitor<@NonNull QVTu2QVTm>
	{
		public CreateVisitor(@NonNull QVTu2QVTm context) {
			super(context);
		}

		public @NonNull QVTu2QVTm getContext() {
			return context;
		}

		@Override
		protected void doRules(@NonNull Transformation tIn, @NonNull Transformation tOut) {
			List<@NonNull Mapping> requiredMappings = new ArrayList<@NonNull Mapping>();
			for (@NonNull Rule rule : ClassUtil.nullFree(tIn.getRule())) {
				if (rule instanceof Mapping) {
					requiredMappings.add((Mapping)rule);
					gatherRequiredMappings((Mapping)rule, requiredMappings);
				}
			}
			createAll(requiredMappings, tOut.getRule());
		}

		private void gatherRequiredMappings(@NonNull Mapping mapping, @NonNull List<@NonNull Mapping> requiredMappings) {
			for (@NonNull Mapping localMapping : ClassUtil.nullFree(mapping.getLocal())) {
				if (!isFoldable(localMapping)) {
					requiredMappings.add(localMapping);
				}
				gatherRequiredMappings(localMapping, requiredMappings);
			}
		}

		@Override
		public @NonNull CoreModel visitCoreModel(@NonNull CoreModel mIn) {
			CoreModel mOut = super.visitCoreModel(mIn);
			mOut.setExternalURI(mIn.getExternalURI().replace(".qvtu.qvtcas", ".qvtm.qvtcas"));
			return mOut;
		}

		@Override
		public @Nullable Mapping visitMapping(@NonNull Mapping mIn) {
			assert !isFoldable(mIn);
			//			if (/*isAbstract(mIn) ||*/ isFoldable(mIn)) {
			//				return null;
			//			}
			if (!context.isRequired(mIn)) {
				return null;
			}
			Mapping mMapping = QVTcoreFactory.eINSTANCE.createMapping();
			context.pushScope(mMapping);
			try {
				MergedMapping mergedMapping = new MergedMapping(this, mIn);
				if (!mergedMapping.analyze()) {
					return null;
				}
				mergedMapping.synthesize(mMapping);
				return mMapping;
			}
			finally {
				context.popScope();
			}
		}

		@Override
		public @NonNull TypedModel visitTypedModel(@NonNull TypedModel tmIn) {
			TypedModel tmOut = super.visitTypedModel(tmIn);
			if (tmOut.getName() == null) {
				tmOut.setName(QVTscheduleConstants.MIDDLE_DOMAIN_NAME);		// FIXME move to super / earlier
			}
			return tmOut;
		}
	}

	protected abstract static class MergedArea
	{
		private static final boolean ASSIGNMENT = true;
		private static final boolean PREDICATE = false;

		protected final @NonNull CreateVisitor createVisitor;
		private final @NonNull List<@NonNull Predicate> guardPredicates = new ArrayList<@NonNull Predicate>();
		private final @NonNull List<@NonNull Predicate> bottomPredicates = new ArrayList<@NonNull Predicate>();
		private @Nullable LinkedHashMap<@NonNull String, @NonNull MergedVariable> variableName2mergedVariables = null;
		private @Nullable LinkedHashMap<@NonNull String, @NonNull List<@NonNull NavigationAssignment>> variableName_property2navigationAssignments = null;
		private @Nullable List<@NonNull NavigationAssignment> navigationAssignmentsAsPredicates = null;

		protected MergedArea(@NonNull CreateVisitor createVisitor) {
			this.createVisitor = createVisitor;
		}

		protected boolean analyze() {
			Area thisArea = getArea(getMapping());
			if (thisArea != null) {
				GuardPattern thisGuardPattern = QVTcoreUtil.getGuardPattern(thisArea);
				Iterables.addAll(guardPredicates, QVTbaseUtil.getPredicates(thisGuardPattern));
				gatherVariables(QVTcoreUtil.getOwnedVariables(thisGuardPattern), MergedVariable.GUARD);
				BottomPattern thisBottomPattern = QVTcoreUtil.getBottomPattern(thisArea);
				gatherVariables(QVTcoreUtil.getOwnedVariables(thisBottomPattern), MergedVariable.BOTTOM);
				gatherAssignments(QVTcoreUtil.getOwnedAssignments(thisBottomPattern), ASSIGNMENT);
				Iterables.addAll(bottomPredicates, QVTbaseUtil.getPredicates(thisBottomPattern));
				gatherVariables(QVTcoreUtil.getOwnedRealizedVariables(thisBottomPattern), MergedVariable.BOTTOM);
			}
			for (@NonNull Area childArea : getChildAreas()) {
				GuardPattern childGuardPattern = QVTcoreUtil.getGuardPattern(childArea);
				Iterables.addAll(guardPredicates, QVTbaseUtil.getPredicates(childGuardPattern));
				gatherVariables(QVTcoreUtil.getOwnedVariables(childGuardPattern), MergedVariable.GUARD);
				BottomPattern childBottomPattern = QVTcoreUtil.getBottomPattern(childArea);
				gatherVariables(QVTcoreUtil.getOwnedVariables(childBottomPattern), MergedVariable.BOTTOM);
				gatherAssignments(QVTcoreUtil.getOwnedAssignments(childBottomPattern), ASSIGNMENT);
				Iterables.addAll(bottomPredicates, QVTbaseUtil.getPredicates(childBottomPattern));
				gatherVariables(QVTcoreUtil.getOwnedRealizedVariables(childBottomPattern), MergedVariable.BOTTOM);
			}
			for (@NonNull Area parentArea : getParentAreas()) {
				assert (parentArea != thisArea);
				GuardPattern parentGuardPattern = QVTcoreUtil.getGuardPattern(parentArea);
				Iterables.addAll(guardPredicates, QVTbaseUtil.getPredicates(parentGuardPattern));
				gatherVariables(QVTcoreUtil.getOwnedVariables(parentGuardPattern), MergedVariable.GUARD);
				BottomPattern parentBottomPattern = QVTcoreUtil.getBottomPattern(parentArea);
				gatherVariables(QVTcoreUtil.getOwnedVariables(parentBottomPattern), MergedVariable.GUARD);			// Hoist
				gatherAssignments(QVTcoreUtil.getOwnedAssignments(parentBottomPattern), PREDICATE);
				Iterables.addAll(guardPredicates, QVTbaseUtil.getPredicates(parentBottomPattern));									// Hoist
				gatherVariables(QVTcoreUtil.getOwnedRealizedVariables(parentBottomPattern), MergedVariable.GUARD);	// Hoist
			}
			for (@NonNull Area siblingArea : getSiblingAreas()) {
				if (siblingArea != thisArea) {
					GuardPattern siblingGuardPattern = QVTcoreUtil.getGuardPattern(siblingArea);
					Iterables.addAll(guardPredicates, QVTbaseUtil.getPredicates(siblingGuardPattern));
					gatherVariables(QVTcoreUtil.getOwnedVariables(siblingGuardPattern), MergedVariable.GUARD);
					BottomPattern siblingBottomPattern = QVTcoreUtil.getBottomPattern(siblingArea);
					gatherVariables(QVTcoreUtil.getOwnedVariables(siblingBottomPattern), MergedVariable.BOTTOM);		// FIXME legacy compatibility
					gatherAssignments(QVTcoreUtil.getOwnedAssignments(siblingBottomPattern), ASSIGNMENT);
					Iterables.addAll(bottomPredicates, QVTbaseUtil.getPredicates(siblingBottomPattern));		// FIXME legacy compatibility
					gatherVariables(QVTcoreUtil.getOwnedRealizedVariables(siblingBottomPattern), MergedVariable.BOTTOM);
				}
			}
			return true;
		}

		protected @Nullable MergedVariable basicGetMergedVariable(@NonNull String name) {
			LinkedHashMap<@NonNull String, @NonNull MergedVariable> variableName2mergedVariables2 = variableName2mergedVariables;
			if (variableName2mergedVariables2 == null) {
				return null;
			}
			return variableName2mergedVariables2.get(name);
		}

		private void gatherAssignments(@NonNull Iterable</*@NonNull*/ Assignment> aIns, boolean asAssignment) {
			for (Assignment aIn : aIns) {
				if (aIn instanceof VariableAssignment) {
					VariableAssignment vaIn = (VariableAssignment)aIn;
					Variable vIn = vaIn.getTargetVariable();
					String name = vIn.getName();
					assert name != null;
					MergedVariable mergedVariable = getMergedVariable(name);
					mergedVariable.addAssignment(vaIn);
				}
				else if (aIn instanceof NavigationAssignment) {
					NavigationAssignment paIn = (NavigationAssignment)aIn;
					if (!asAssignment) {
						List<@NonNull NavigationAssignment> navigationAssignmentsAsPredicates2 = navigationAssignmentsAsPredicates;
						if (navigationAssignmentsAsPredicates2 == null) {
							navigationAssignmentsAsPredicates2 = navigationAssignmentsAsPredicates = new ArrayList<@NonNull NavigationAssignment>();
						}
						navigationAssignmentsAsPredicates2.add(paIn);
					}
					else {
						OCLExpression eIn = paIn.getSlotExpression();
						Property targetProperty = QVTcoreUtil.getTargetProperty(paIn);
						if (eIn instanceof VariableExp) {
							VariableDeclaration vIn = ((VariableExp)eIn).getReferredVariable();
							String key = vIn.getName() + "%" + targetProperty.toString();
							assert key != null;
							LinkedHashMap<@NonNull String, @NonNull List<@NonNull NavigationAssignment>> variableName_property2navigationAssignments2 = variableName_property2navigationAssignments;
							if (variableName_property2navigationAssignments2 == null) {
								variableName_property2navigationAssignments2 = variableName_property2navigationAssignments = new LinkedHashMap<@NonNull String, @NonNull List<@NonNull NavigationAssignment>>();
							}
							List<@NonNull NavigationAssignment> navigationAssignments = variableName_property2navigationAssignments2.get(key);
							if (navigationAssignments == null) {
								navigationAssignments = new ArrayList<@NonNull NavigationAssignment>();
								variableName_property2navigationAssignments2.put(key, navigationAssignments);
							}
							navigationAssignments.add(paIn);
						}
					}
				}
			}
		}

		private <T extends Variable> void gatherVariables(@NonNull Iterable</*@NonNull*/ ? extends T> vIns, boolean isGuard) {
			for (T vIn : vIns) {
				if (vIn != null) {
					String name = vIn.getName();
					assert name != null;
					MergedVariable mergedVariable = getMergedVariable(name);
					mergedVariable.addVariable(vIn, isGuard);
				}
			}
		}

		protected abstract @Nullable Area getArea(@NonNull Mapping uMapping);

		protected abstract @NonNull  Iterable<? extends @NonNull Area> getChildAreas();

		public @NonNull CreateVisitor getCreateVisitor() {
			return createVisitor;
		}

		protected abstract @NonNull Mapping getMapping();

		protected @NonNull MergedVariable getMergedVariable(@NonNull String name) {
			LinkedHashMap<@NonNull String, @NonNull MergedVariable> variableName2mergedVariables2 = variableName2mergedVariables;
			if (variableName2mergedVariables2 == null) {
				variableName2mergedVariables = variableName2mergedVariables2 = new LinkedHashMap<@NonNull String, @NonNull MergedVariable>();
			}
			MergedVariable mergedVariable = variableName2mergedVariables2.get(name);
			if (mergedVariable == null) {
				mergedVariable = new MergedVariable(this, name);
				variableName2mergedVariables2.put(name, mergedVariable);
			}
			return mergedVariable;
		}

		protected abstract @NonNull  Iterable<? extends @NonNull Area> getParentAreas();

		protected abstract @NonNull  Iterable<? extends @NonNull Area> getSiblingAreas();

		protected boolean isEnforced() {
			return false;
		}

		protected void synthesize(@NonNull Area mArea) {
			GuardPattern mGuardPattern = QVTcoreFactory.eINSTANCE.createGuardPattern();
			mArea.setGuardPattern(mGuardPattern);
			createVisitor.createAll(guardPredicates, mGuardPattern.getPredicate());
			if (navigationAssignmentsAsPredicates != null) {
				for (@NonNull NavigationAssignment paIn : navigationAssignmentsAsPredicates) {
					@NonNull Predicate pOut = QVTbaseFactory.eINSTANCE.createPredicate();
					createVisitor.getContext().addTrace(paIn, pOut);
					// The condition expression is copied during update once replacement variables exist.
					createVisitor.createAll(paIn.getOwnedComments(), pOut.getOwnedComments());
					mGuardPattern.getPredicate().add(pOut);
				}
			}
			//
			BottomPattern mBottomPattern = QVTcoreFactory.eINSTANCE.createBottomPattern();
			mArea.setBottomPattern(mBottomPattern);
			createVisitor.createAll(bottomPredicates, mBottomPattern.getPredicate());
			synthesizeNavigationAssignments(QVTcoreUtil.Internal.getOwnedAssignmentsList(mBottomPattern));
			if (variableName2mergedVariables != null) {
				for (@NonNull MergedVariable mergedVariable : variableName2mergedVariables.values()) {		// FIXME Change to alphabetical sort
					mergedVariable.synthesize(mArea);
				}
			}
			//
			QVTu2QVTm qvtu2qvtm = createVisitor.getContext();
			for (@NonNull Area uArea : Iterables.concat(getSiblingAreas(), getParentAreas(), getChildAreas())) {
				qvtu2qvtm.addTrace(uArea, mArea);
				if (uArea == getArea(getMapping())) {				// FIXME Legacy compatibility
					createVisitor.createAll(uArea.getOwnedComments(), mArea.getOwnedComments());
				}
				//
				GuardPattern uGuardPattern = QVTcoreUtil.getGuardPattern(uArea);
				qvtu2qvtm.addTrace(uGuardPattern, mGuardPattern);
				createVisitor.createAll(uGuardPattern.getOwnedComments(), mGuardPattern.getOwnedComments());
				//
				BottomPattern uBottomPattern = QVTcoreUtil.getBottomPattern(uArea);
				qvtu2qvtm.addTrace(uBottomPattern, mBottomPattern);
				createVisitor.createAll(uBottomPattern.getOwnedComments(), mArea.getOwnedComments());
			}
		}

		private void synthesizeNavigationAssignment(@NonNull List<@NonNull NavigationAssignment> navigationAssignments, @NonNull List<Assignment> uAssignments) {
			for (@NonNull NavigationAssignment navigationAssignment : navigationAssignments) {
				uAssignments.add(createVisitor.create(navigationAssignment));	// FIXME merge
				// break;
			}
		}

		private void synthesizeNavigationAssignments(@NonNull List</*@NoonNull*/ Assignment> uAssignments) {
			LinkedHashMap<@NonNull String, @NonNull List<@NonNull NavigationAssignment>> variableName_property2navigationAssignments2 = variableName_property2navigationAssignments;
			if (variableName_property2navigationAssignments2 != null) {
				for (@NonNull List<@NonNull NavigationAssignment> navigationAssignments : variableName_property2navigationAssignments2.values()) {		// FIXME Change to alphabetical sort
					synthesizeNavigationAssignment(navigationAssignments, uAssignments);
				}
			}
		}
	}

	protected static class MergedDomain extends MergedArea
	{
		/**
		 * The merged mapping to which this merged domain contributes.
		 */
		protected final @NonNull MergedMapping mergedMapping;

		/**
		 * The typed model that identifies this domain.
		 */
		protected final @NonNull TypedModel uTypedModel;

		/**
		 * A domain, not necessarily from the root or local mapping that has the check/enfoprce flags.
		 */
		protected final @NonNull CoreDomain uExampleDomain;

		/**
		 * The local domain for the local mapping., which may be null if there is no local domain.
		 */
		protected final @Nullable CoreDomain uLocalDomain;

		/**
		 * All local QVTi CoreDomains that merge up into the QVTm CoreDomain.
		 */
		private final @NonNull List<@NonNull CoreDomain> childDomains = new ArrayList<@NonNull CoreDomain>();

		/**
		 * All context QVTi CoreDomains that predicate the QVTm CoreDomain.
		 */
		private final @NonNull List<@NonNull CoreDomain> parentDomains = new ArrayList<@NonNull CoreDomain>();

		/**
		 * All refined QVTi CoreDomains (including this domain) that merge into the QVTm CoreDomain.
		 */
		private final @NonNull List<@NonNull CoreDomain> siblingDomains = new ArrayList<@NonNull CoreDomain>();

		public MergedDomain(@NonNull CreateVisitor createVisitor, @NonNull MergedMapping mergedMapping, @NonNull TypedModel uTypedModel, @NonNull CoreDomain uExampleDomain) {
			super(createVisitor);
			this.mergedMapping = mergedMapping;
			this.uTypedModel = uTypedModel;
			this.uExampleDomain = uExampleDomain;
			this.uLocalDomain = QVTcoreUtil.getDomain(mergedMapping.uMapping, uTypedModel);
		}

		@Override
		public boolean analyze() {
			for (@NonNull Mapping childMapping : mergedMapping.getChildAreas()) {
				CoreDomain childDomain = QVTcoreUtil.getDomain(childMapping, uTypedModel);
				if (childDomain != null) {
					childDomains.add(childDomain);
				}
			}
			for (@NonNull Mapping parentMapping : mergedMapping.getParentAreas()) {
				CoreDomain parentDomain = QVTcoreUtil.getDomain(parentMapping, uTypedModel);
				if (parentDomain != null) {
					parentDomains.add(parentDomain);
				}
			}
			for (@NonNull Mapping siblingMapping : mergedMapping.getSiblingAreas()) {
				CoreDomain siblingDomain = QVTcoreUtil.getDomain(siblingMapping, uTypedModel);
				if (siblingDomain != null) {
					siblingDomains.add(siblingDomain);
				}
			}
			return super.analyze();
		}

		//		@Override
		//		protected @NonNull CoreDomain zzgetArea() {
		//			return uNonLocalDomain;
		//		}

		@Override
		protected @Nullable CoreDomain getArea(@NonNull Mapping uMapping) {
			return QVTcoreUtil.getDomain(uMapping, uTypedModel);
		}

		@Override
		protected @NonNull Iterable<@NonNull CoreDomain> getChildAreas() {
			return childDomains;
		}

		@Override
		protected @NonNull Mapping getMapping() {
			return mergedMapping.uMapping;
		}

		@Override
		protected @NonNull Iterable<@NonNull CoreDomain> getParentAreas() {
			return parentDomains;
		}

		@Override
		protected @NonNull Iterable<@NonNull CoreDomain> getSiblingAreas() {
			return siblingDomains;
		}

		@Override
		protected boolean isEnforced() {
			return uExampleDomain.isIsEnforceable();			// FIXME all domains ??
		}

		public @NonNull CoreDomain synthesize() {
			CoreDomain mDomain = QVTcoreFactory.eINSTANCE.createCoreDomain();
			//			mDomain.setTypedModel(uTypedModel);
			mDomain.setName(uTypedModel.getName());
			boolean isCheckable = uExampleDomain.isIsCheckable();
			boolean isEnforceable = uExampleDomain.isIsEnforceable();
			for (@NonNull CoreDomain domain : parentDomains) {
				if (domain.isIsCheckable()) {
					isCheckable = true;
				}
				if (domain.isIsEnforceable()) {
					isEnforceable = true;
				}
			}
			for (@NonNull CoreDomain domain : siblingDomains) {
				if (domain.isIsCheckable()) {
					isCheckable = true;
				}
				if (domain.isIsEnforceable()) {
					isEnforceable = true;
				}
			}
			mDomain.setIsCheckable(isCheckable);
			mDomain.setIsEnforceable(isEnforceable);
			synthesize(mDomain);
			return mDomain;
		}

		@Override
		public String toString() {
			return uExampleDomain.toString();
		}
	}

	protected static class MergedMapping extends MergedArea
	{
		/**
		 * The QVTu Mapping into which contributions may merge.
		 */
		protected final @NonNull Mapping uMapping;

		/**
		 * All local QVTi Mappings that merge up into the QVTm Mappings.
		 */
		private final @NonNull List<@NonNull Mapping> childMappings = new ArrayList<@NonNull Mapping>();

		/**
		 * All context QVTi Mappings that predicate the QVTm Mappings.
		 */
		private final @NonNull List<@NonNull Mapping> parentMappings = new ArrayList<@NonNull Mapping>();

		/**
		 * All refined QVTi Mappings (including this domain) that merge into the QVTm Mappings.
		 */
		private final @NonNull List<@NonNull Mapping> siblingMappings = new ArrayList<@NonNull Mapping>();

		/**
		 * The merge for each domain.
		 */
		private final @NonNull Map<@Nullable TypedModel, @NonNull MergedDomain> uTypedModel2mergedDomain = new HashMap<@Nullable TypedModel, @NonNull MergedDomain>();

		public MergedMapping(@NonNull CreateVisitor createVisitor, @NonNull Mapping uMapping) {
			super(createVisitor);
			this.uMapping = uMapping;
		}

		@Override
		public boolean analyze() {
			@SuppressWarnings("unused") String name = uMapping.getName();
			computeChildMappings(childMappings, uMapping);
			computeSiblingMappings(siblingMappings, uMapping);
			for (@NonNull Mapping contextMapping : siblingMappings) {
				if (contextMapping != uMapping) {			// FIXME Legacy order
					computeChildMappings(childMappings, contextMapping);
				}
			}
			computeParentMappings(parentMappings, uMapping);
			for (@NonNull Mapping uMapping : Iterables.concat(siblingMappings, parentMappings, childMappings)) {
				for (@NonNull Domain uDomain : ClassUtil.nullFree(uMapping.getDomain())) {
					TypedModel uTypedModel = QVTcoreUtil.getTypedModel(uDomain);
					if (uTypedModel2mergedDomain.get(uTypedModel) == null) {
						uTypedModel2mergedDomain.put(uTypedModel, new MergedDomain(createVisitor, this, uTypedModel, (@NonNull CoreDomain) uDomain));
					}
				}
			}
			for (@NonNull MergedDomain mergedDomain : uTypedModel2mergedDomain.values()) {
				if (!mergedDomain.analyze()) {
					return false;
				}
			}
			return super.analyze();
		}

		private void computeChildMappings(@NonNull List<@NonNull Mapping> childMappings, @NonNull Mapping parentMapping) {
			for (@NonNull Mapping childMapping : ClassUtil.nullFree(parentMapping.getLocal())) {
				if (isFoldable(childMapping)) {
					assert !childMappings.contains(childMapping) : "Local mappings cannot be cyclic";
					childMappings.add(childMapping);
					computeChildMappings(childMappings, childMapping);
				}
			}
		}

		private void computeParentMappings(@NonNull List<@NonNull Mapping> parentMappings, @NonNull Mapping childMapping) {
			Mapping parentMapping = childMapping.getContext();
			if (parentMapping != null) {
				assert !parentMappings.contains(parentMapping) : "Context mappings cannot be cyclic";
				computeSiblingMappings(parentMappings, parentMapping);		// All siblings of the parent are also parents. ?? folded too ??
				computeParentMappings(parentMappings, parentMapping);
			}
		}

		private void computeSiblingMappings(@NonNull List<@NonNull Mapping> siblingMappings, @NonNull Mapping refinedMapping) {
			if (!siblingMappings.contains(refinedMapping)) {		// FIXME cannot be cyclic
				siblingMappings.add(refinedMapping);
				for (@NonNull Mapping specificationMapping : ClassUtil.nullFree(refinedMapping.getSpecification())) {
					assert refinedMapping.getContext() == null : "Local mapping cannot refine another";
					computeSiblingMappings(siblingMappings, specificationMapping);
				}
			}
		}

		@Override
		protected @Nullable Mapping getArea(@NonNull Mapping uMapping) {
			return uMapping;
		}

		@Override
		protected @NonNull Iterable<@NonNull Mapping> getChildAreas() {
			return childMappings;
		}

		@Override
		protected @NonNull Mapping getMapping() {
			return uMapping;
		}

		@Override
		protected @NonNull MergedVariable getMergedVariable(@NonNull String name) {
			for (@NonNull MergedDomain mergedDomain : uTypedModel2mergedDomain.values()) {
				MergedVariable mergedVariable = mergedDomain.basicGetMergedVariable(name);
				if (mergedVariable != null) {
					return mergedVariable;
				}
			}
			return super.getMergedVariable(name);
		}

		@Override
		protected @NonNull Iterable<@NonNull Mapping> getParentAreas() {
			return parentMappings;
		}

		@Override
		protected @NonNull Iterable<@NonNull Mapping> getSiblingAreas() {
			return siblingMappings;
		}

		public void synthesize(@NonNull Mapping mMapping) {
			String name = createVisitor.getContext().getMappingName(uMapping);
			mMapping.setName(name);
			super.synthesize(mMapping);
			Transformation uTransformation = QVTbaseUtil.getContainingTransformation(uMapping);
			for (@NonNull TypedModel uTypedModel : QVTbaseUtil.getModelParameters(uTransformation)) {
				MergedDomain mergedDomain = uTypedModel2mergedDomain.get(uTypedModel);
				if (mergedDomain != null) {
					CoreDomain mDomain = mergedDomain.synthesize();
					mMapping.getDomain().add(mDomain);
				}
			}
		}

		@Override
		public String toString() {
			return uMapping.toString();
		}
	}

	protected static class MergedVariable
	{
		public static final boolean GUARD = true;
		public static final boolean BOTTOM = false;
		protected final @NonNull CreateVisitor createVisitor;
		protected final @NonNull MergedArea mergedArea;
		protected final @NonNull String name;
		private boolean isGuard = BOTTOM;
		private boolean isRealized = false;
		private @Nullable CompleteClass mergedType = null;
		private boolean isRequired = false;
		private @Nullable List<@NonNull Variable> variables = null;
		private @Nullable List<@NonNull VariableAssignment> assignments = null;

		protected MergedVariable(@NonNull MergedArea mergedArea, @NonNull String name) {
			this.createVisitor = mergedArea.getCreateVisitor();
			this.mergedArea = mergedArea;
			this.name = name;
		}

		public void addAssignment(@NonNull VariableAssignment variableAssignment) {
			List<@NonNull VariableAssignment> assignments2 = assignments;
			if (assignments2 == null) {
				assignments = assignments2 = new ArrayList<@NonNull VariableAssignment>();
			}
			assignments2.add(variableAssignment);
		}

		public void addVariable(@NonNull Variable variable, boolean isGuard) {
			if (isGuard) {
				this.isGuard = true;
			}
			else if (variable instanceof RealizedVariable) {
				this.isRealized = true;
			}
			if (variable.isIsRequired()) {
				this.isRequired = true;
			}
			List<@NonNull Variable> variables2 = variables;
			if (variables2 == null) {
				variables = variables2 = new ArrayList<@NonNull Variable>();
			}
			assert !variables2.contains(variable);
			variables2.add(variable);
			EnvironmentFactory environmentFactory = createVisitor.getContext().getEnvironmentFactory();
			Type type = variable.getType();
			assert type != null;
			CompleteClass completeType = environmentFactory.getCompleteModel().getCompleteClass(type);
			CompleteClass mergedType2 = mergedType;
			if (mergedType2 == null) {
				mergedType = mergedType2 = completeType;
			}
			else if (completeType.conformsTo(mergedType2)) {
				mergedType = mergedType2 = completeType;
			}
			else {
				assert mergedType2.conformsTo(completeType);
			}
		}

		public void synthesize(@NonNull Area mArea) {
			List<@NonNull VariableAssignment> assignments2 = assignments;
			List<@NonNull Variable> variables2 = variables;
			if (variables2 != null) {
				Variable mVariable = QVTcoreFactory.eINSTANCE.createRealizedVariable();
				if (isRealized) {
					RealizedVariable realizedVariable = QVTcoreFactory.eINSTANCE.createRealizedVariable();
					mVariable = realizedVariable;
					mArea.getBottomPattern().getRealizedVariable().add(realizedVariable);
				}
				else {
					if (isGuard) {
						mVariable = QVTcoreFactory.eINSTANCE.createGuardVariable();
						mArea.getGuardPattern().getVariable().add(mVariable);
					}
					else {
						mVariable = QVTcoreFactory.eINSTANCE.createBottomVariable();
						mArea.getBottomPattern().getVariable().add(mVariable);
					}
				}
				mVariable.setName(name);
				if (mergedType != null) {
					mVariable.setType(mergedType.getPrimaryClass());
				}
				mVariable.setIsRequired(isRequired);
				for (@NonNull Variable uVariable : variables2) {
					createVisitor.getContext().addTrace(uVariable, mVariable);
					createVisitor.createAll(uVariable.getOwnedComments(), mVariable.getOwnedComments());
				}
				if (assignments2 != null) {
					final Variable finalMVariable = mVariable;
					createVisitor.getContext().addUpdater(finalMVariable, new Updater()
					{
						@Override
						public void update(@NonNull UpdateVisitor updateVisitor) {
							finalMVariable.setOwnedInit(updateVisitor.createCastCopy(assignments2.get(0).getValue(), finalMVariable.getType()));
							for (@NonNull VariableAssignment uVariableAssignment : assignments2) {
								createVisitor.getContext().addTrace(uVariableAssignment, finalMVariable);
								createVisitor.createAll(uVariableAssignment.getOwnedComments(), finalMVariable.getOwnedComments());
							}
						}
					});
				}
			}
			else {
				assert assignments2 != null;
				VariableAssignment mVariableAssignment = createVisitor.create(assignments2.get(0));
				assert mVariableAssignment != null;
				//				for (@NonNull VariableAssignment uVariableAssignment : assignments2) {
				//					createVisitor.getContext().addTrace(uVariableAssignment, mVariableAssignment);
				//				}
			}
		}

		@Override
		public String toString() {
			return name;
		}
	}

	protected static class UpdateVisitor extends AbstractUpdateVisitor<@NonNull QVTu2QVTm>
	{
		public UpdateVisitor(@NonNull QVTu2QVTm context) {
			super(context);
		}

		@Override
		public @Nullable Object visitVariable(@NonNull Variable mVariable) {
			Updater updater = context.getUpdater(mVariable);
			if (updater != null) {
				updater.update(this);
				return null;
			}
			else if (mVariable.eContainer() instanceof CorePattern) {
				Variable uVariable = context.equivalentSource(mVariable);
				mVariable.setOwnedInit(createCastCopy(uVariable.getOwnedInit(), uVariable.getType()));
				return null;
			}
			else {
				return super.visitVariable(mVariable);
			}
		}
	}

	protected static interface Updater
	{
		void update(@NonNull UpdateVisitor updateVisitor);
	}

	/**
	 * A local mapping may be folded into its context if it has no guard variables or predicates and so cannot execute independently of its context.
	 */
	private static boolean isFoldable(@NonNull Mapping mapping) {
		if (mapping.getContext() == null) {
			return false;
		}
		assert mapping.getSpecification().isEmpty() : " Local mappings cannot be a refinement.";
		GuardPattern guardPattern = mapping.getGuardPattern();
		if (guardPattern.getVariable().size() > 0) {
			return false;
		}
		if (guardPattern.getPredicate().size() > 0) {
			return false;
		}
		for (Domain d : mapping.getDomain()) {
			CoreDomain cd = (CoreDomain)d;
			guardPattern = cd.getGuardPattern();
			if (guardPattern.getVariable().size() > 0) {
				return false;
			}
			if (guardPattern.getPredicate().size() > 0) {
				return false;
			}
		}
		return true;
	}

	private final @NonNull Map<@NonNull Element, @NonNull Updater> element2updater = new HashMap<@NonNull Element, @NonNull Updater>();

	private final @NonNull SymbolNameReservation symbolNameReservation = new SymbolNameReservation();

	public QVTu2QVTm(@NonNull EnvironmentFactory environmentFactory) {
		super(environmentFactory);
	}

	public void addUpdater(@NonNull Element mElement, @NonNull Updater updater) {
		Updater oldUpdater = element2updater.put(mElement, updater);
		assert oldUpdater == null;
	}

	@Override
	protected @NonNull CreateVisitor createCreateVisitor() {
		return new CreateVisitor(this);
	}

	@Override
	protected @NonNull UpdateVisitor createUpdateVisitor() {
		return new UpdateVisitor(this);
	}

	/**
	 * Return a unique name for uMapping. Local mappings have a name constructed from their context and guard variable names.
	 * All mappings have their names suffixed if necessary for uniqueness.
	 */
	public @NonNull String getMappingName(@NonNull Mapping uMapping) {
		SymbolNameBuilder s = new SymbolNameBuilder();
		String name = uMapping.getName();
		if (name != null) {
			s.appendName(name);
		}
		else {
			Mapping uNamedMapping = uMapping;
			while (uNamedMapping.getContext() != null) {
				uNamedMapping = uNamedMapping.getContext();
			}
			s.appendString(PivotUtil.getName(uNamedMapping));
			List<@NonNull String> guardVariableNames = new ArrayList<@NonNull String>();
			for (@NonNull Variable guardVariable : ClassUtil.nullFree(uMapping.getGuardPattern().getVariable())) {
				guardVariableNames.add(PivotUtil.getName(guardVariable));
			}
			for (@NonNull Domain uDomain : ClassUtil.nullFree(uMapping.getDomain())) {
				for (@NonNull Variable guardVariable : ClassUtil.nullFree(((CoreDomain)uDomain).getGuardPattern().getVariable())) {
					guardVariableNames.add(PivotUtil.getName(guardVariable));
				}
			}
			Collections.sort(guardVariableNames);
			for (@NonNull String guardVariableName : guardVariableNames) {
				s.appendString("_");
				s.appendString(guardVariableName);
			}
		}
		return symbolNameReservation.reserveSymbolName(s, uMapping);
	}

	public @Nullable Updater getUpdater(@NonNull Element mElement) {
		return element2updater.get(mElement);
	}

	private boolean hasVariables(Area a) {
		return !(a.getGuardPattern().getVariable().isEmpty() ||
				a.getBottomPattern().getVariable().isEmpty() ||
				a.getBottomPattern().getRealizedVariable().isEmpty());
	}

	/**
	 * Return false if the mapping can be omitted, either because it is not refined or because it contributes no variables.
	 */
	private boolean isRequired(@NonNull Mapping m) {
		List<@NonNull Mapping> refinements = ClassUtil.nullFree(m.getRefinement());
		if (refinements.isEmpty())
			return true;
		for (@NonNull Mapping refining : refinements) {
			for (Domain rd : refining.getDomain()) {
				if (hasVariables((Area) rd))
					return true;
			}
			if (hasVariables(m))
				return true;
		}
		return false;
	}
}