[498400] Eliminate HEAD/STEP distinction in NodeRole

8 files changed, 73 insertions, 203 deletions

diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractNode.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractNode.java
index 12e454c4a..7248499cc 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractNode.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractNode.java
@@ -66,6 +66,7 @@ public abstract class AbstractNode implements Node
 	protected final @NonNull String name;
 	private @NonNull ClassDatumAnalysis classDatumAnalysis;
 	private final boolean isDataType;
+	private boolean isHead = false;
 	private @Nullable NodeConnection incomingConnection = null;
 	private @Nullable List<@NonNull Edge> incomingEdges = null;
 	private @Nullable List<@NonNull NodeConnection> outgoingConnections = null;
@@ -408,7 +409,7 @@ public abstract class AbstractNode implements Node
 	}
 
 	protected @NonNull Integer getPenwidth() {
-		return nodeRole.getPenwidth();
+		return isHead() ? Role.HEAD_WIDTH : Role.LINE_WIDTH;
 	}
 
 	@Override
@@ -532,7 +533,7 @@ public abstract class AbstractNode implements Node
 
 	@Override
 	public boolean isHead() {
-		return nodeRole.isHead();
+		return isHead;
 	}
 
 	@Override
@@ -676,12 +677,12 @@ public abstract class AbstractNode implements Node
 
 	@Override
 	public void resetHead() {
-		this.nodeRole = this.nodeRole.resetHead();
+		this.isHead = false;
 	}
 
 	@Override
 	public void setHead() {
-		this.nodeRole = this.nodeRole.setHead();
+		this.isHead = true;
 	}
 
 	public void setLabel(@NonNull GraphStringBuilder s) {
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractNodeRole.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractNodeRole.java
index d68bb92ae..3949e914d 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractNodeRole.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractNodeRole.java
@@ -83,11 +83,6 @@ public abstract class AbstractNodeRole extends AbstractRole implements NodeRole
 	}
 
 	@Override
-	public @NonNull Integer getPenwidth() {
-		return isHead() /*&& !isResult()*/ ? HEAD_WIDTH : LINE_WIDTH;
-	}
-
-	@Override
 	public @Nullable String getShape() {
 		return null;
 	}
@@ -108,11 +103,6 @@ public abstract class AbstractNodeRole extends AbstractRole implements NodeRole
 	}
 
 	@Override
-	public boolean isHead() {
-		return false;
-	}
-
-	@Override
 	public boolean isInternal() {
 		return false;
 	}
@@ -154,20 +144,4 @@ public abstract class AbstractNodeRole extends AbstractRole implements NodeRole
 		}
 		throw new IllegalStateException(this + " cannot be merged with " + nodeRole);
 	}
-
-	@Override
-	public @NonNull NodeRole resetHead() {
-		if (!isHead()) {
-			return this;
-		}
-		throw new IllegalStateException(this + " cannot be reset as a non-head");
-	}
-
-	@Override
-	public @NonNull NodeRole setHead() {
-		if (isHead()) {
-			return this;
-		}
-		throw new IllegalStateException(this + " cannot be set as a head");
-	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/NodeRole.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/NodeRole.java
index a565c656a..8ec88cf19 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/NodeRole.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/NodeRole.java
@@ -31,25 +31,16 @@ public interface NodeRole extends Role
 	@NonNull Node createNode(@NonNull Region region, @NonNull String name, @NonNull TypedElement typedElement);
 
 	/**
-	 * Return the pen width with which this edge is drawn.
-	 */
-	@NonNull Integer getPenwidth();
-
-	/**
 	 * Return the shape or null for default.
 	 */
 	@Nullable String getShape();
 
-	//	@Nullable String getStyle();
-
 	boolean isComposed();
 
 	boolean isExpression();
 
 	boolean isExtraGuardVariable();
 
-	boolean isHead();
-
 	boolean isInternal();
 
 	boolean isIterator();
@@ -68,14 +59,4 @@ public interface NodeRole extends Role
 	 * Return the merged role combining this role and nodeRole.
 	 */
 	@NonNull NodeRole merge(@NonNull NodeRole nodeRole);
-
-	/**
-	 * Redesignate a head node as not-a-head, typically following a multi-headed split.
-	 */
-	@NonNull NodeRole resetHead();
-
-	/**
-	 * Redesignate a guard node as a head.
-	 */
-	@NonNull NodeRole setHead();
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/Nodes.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/Nodes.java
index db6481bcc..053e66475 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/Nodes.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/Nodes.java
@@ -34,13 +34,6 @@ import org.eclipse.qvtd.pivot.schedule.ClassDatum;
  */
 public class Nodes
 {
-	private static enum HeadableEnum { STEP, HEAD };
-	private static enum NavigableEnum { UNNAVIGABLE, NAVIGABLE };
-
-	private static @NonNull NavigableEnum asNavigable(boolean isNavigable) {
-		return isNavigable ? NavigableEnum.NAVIGABLE : NavigableEnum.UNNAVIGABLE;
-	}
-
 	private static final class ComposingNodeRole extends AbstractNodeRole
 	{
 		private static final @NonNull ComposingNodeRole COMPOSING = new ComposingNodeRole();
@@ -73,11 +66,6 @@ public class Nodes
 		}
 
 		@Override
-		public @NonNull Integer getPenwidth() {
-			return HEAD_WIDTH;
-		}
-
-		@Override
 		public @NonNull String getShape() {
 			return "circle";
 		}
@@ -99,11 +87,6 @@ public class Nodes
 		public boolean isExtraGuardVariable() {
 			return true;
 		}
-
-		@Override
-		public boolean isHead() {
-			return true;
-		}
 	}
 
 	private static final class InputNodeRole extends AbstractNodeRole
@@ -136,16 +119,6 @@ public class Nodes
 		public @NonNull TypedNode createNode(@NonNull Region region, @NonNull String name, @NonNull TypedElement typedElement) {
 			throw new UnsupportedOperationException();
 		}
-
-		@Override
-		public @NonNull Integer getPenwidth() {
-			return Role.HEAD_WIDTH; //isHead ? Role.HEAD_WIDTH : Role.GUARD_WIDTH;
-		}
-
-		@Override
-		public boolean isHead() {
-			return true;
-		}
 	}
 
 	private static final class IteratorNodeRole extends AbstractNodeRole
@@ -274,11 +247,6 @@ public class Nodes
 		}
 
 		@Override
-		public @NonNull Integer getPenwidth() {
-			return LINE_WIDTH;
-		}
-
-		@Override
 		public @NonNull String getShape() {
 			return "ellipse";
 		}
@@ -301,66 +269,34 @@ public class Nodes
 
 	private static class PatternNodeRole extends AbstractNodeRole
 	{
-		private static final @NonNull PatternNodeRole CONSTANT_NAVIGABLE_STEP = new PatternNodeRole(Role.Phase.CONSTANT, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
-		private static final @NonNull PatternNodeRole CONSTANT_UNNAVIGABLE_STEP = new PatternNodeRole(Role.Phase.CONSTANT, NavigableEnum.UNNAVIGABLE, HeadableEnum.STEP);
-		private static final @NonNull PatternNodeRole LOADED_NAVIGABLE_HEAD = new PatternNodeRole(Role.Phase.LOADED, NavigableEnum.NAVIGABLE, HeadableEnum.HEAD);
-		private static final @NonNull PatternNodeRole LOADED_NAVIGABLE_STEP = new PatternNodeRole(Role.Phase.LOADED, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
-		private static final @NonNull PatternNodeRole LOADED_UNNAVIGABLE_STEP = new PatternNodeRole(Role.Phase.LOADED, NavigableEnum.UNNAVIGABLE, HeadableEnum.STEP);
-		private static final @NonNull PatternNodeRole PREDICATED_NAVIGABLE_HEAD = new PatternNodeRole(Role.Phase.PREDICATED, NavigableEnum.NAVIGABLE, HeadableEnum.HEAD);
-		private static final @NonNull PatternNodeRole PREDICATED_NAVIGABLE_STEP = new PatternNodeRole(Role.Phase.PREDICATED, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
-		private static final @NonNull PatternNodeRole PREDICATED_UNNAVIGABLE_HEAD = new PatternNodeRole(Role.Phase.PREDICATED, NavigableEnum.UNNAVIGABLE, HeadableEnum.HEAD);
-		private static final @NonNull PatternNodeRole PREDICATED_UNNAVIGABLE_STEP = new PatternNodeRole(Role.Phase.PREDICATED, NavigableEnum.UNNAVIGABLE, HeadableEnum.STEP);
-		private static final @NonNull PatternNodeRole REALIZED_NAVIGABLE_STEP = new PatternNodeRole(Role.Phase.REALIZED, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
-		private static final @NonNull PatternNodeRole REALIZED_UNNAVIGABLE_STEP = new PatternNodeRole(Role.Phase.REALIZED, NavigableEnum.UNNAVIGABLE, HeadableEnum.STEP);
-		private static final @NonNull PatternNodeRole SPECULATED_NAVIGABLE_HEAD = new PatternNodeRole(Role.Phase.SPECULATED, NavigableEnum.NAVIGABLE, HeadableEnum.HEAD);
-		private static final @NonNull PatternNodeRole SPECULATED_NAVIGABLE_STEP = new PatternNodeRole(Role.Phase.SPECULATED, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
-		private static final @NonNull PatternNodeRole SPECULATION_NAVIGABLE_STEP = new PatternNodeRole(Role.Phase.SPECULATION, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
-
-		public static @NonNull PatternNodeRole getPatternNodeRole(@NonNull Phase phase, @NonNull NavigableEnum navigable, @NonNull HeadableEnum guardable) {
-			switch (navigable) {
-				case NAVIGABLE: {
-					switch (guardable) {
-						case HEAD: {
-							switch (phase) {
-								case LOADED: return LOADED_NAVIGABLE_HEAD;
-								case PREDICATED: return PREDICATED_NAVIGABLE_HEAD;
-								case SPECULATED: return SPECULATED_NAVIGABLE_HEAD;
-							}
-							break;
-						}
-						case STEP: {
-							switch (phase) {
-								case CONSTANT: return CONSTANT_NAVIGABLE_STEP;
-								case LOADED: return LOADED_NAVIGABLE_STEP;
-								case PREDICATED: return PREDICATED_NAVIGABLE_STEP;
-								case REALIZED: return REALIZED_NAVIGABLE_STEP;
-								case SPECULATED: return SPECULATED_NAVIGABLE_STEP;
-								case SPECULATION: return SPECULATION_NAVIGABLE_STEP;
-							}
-							break;
-						}
-					}
-					break;
+		private static final @NonNull PatternNodeRole CONSTANT_NAVIGABLE = new PatternNodeRole(Role.Phase.CONSTANT, true);
+		private static final @NonNull PatternNodeRole CONSTANT_UNNAVIGABLE = new PatternNodeRole(Role.Phase.CONSTANT, false);
+		private static final @NonNull PatternNodeRole LOADED_NAVIGABLE = new PatternNodeRole(Role.Phase.LOADED, true);
+		private static final @NonNull PatternNodeRole LOADED_UNNAVIGABLE = new PatternNodeRole(Role.Phase.LOADED, false);
+		private static final @NonNull PatternNodeRole PREDICATED_NAVIGABLE = new PatternNodeRole(Role.Phase.PREDICATED, true);
+		private static final @NonNull PatternNodeRole PREDICATED_UNNAVIGABLE = new PatternNodeRole(Role.Phase.PREDICATED, false);
+		private static final @NonNull PatternNodeRole REALIZED_NAVIGABLE = new PatternNodeRole(Role.Phase.REALIZED, true);
+		private static final @NonNull PatternNodeRole REALIZED_UNNAVIGABLE = new PatternNodeRole(Role.Phase.REALIZED, false);
+		private static final @NonNull PatternNodeRole SPECULATED_NAVIGABLE = new PatternNodeRole(Role.Phase.SPECULATED, true);
+		private static final @NonNull PatternNodeRole SPECULATION_NAVIGABLE = new PatternNodeRole(Role.Phase.SPECULATION, true);
+
+		public static @NonNull PatternNodeRole getPatternNodeRole(@NonNull Phase phase, boolean isNavigable) {
+			if (isNavigable) {
+				switch (phase) {
+					case CONSTANT: return CONSTANT_NAVIGABLE;
+					case LOADED: return LOADED_NAVIGABLE;
+					case PREDICATED: return PREDICATED_NAVIGABLE;
+					case REALIZED: return REALIZED_NAVIGABLE;
+					case SPECULATED: return SPECULATED_NAVIGABLE;
+					case SPECULATION: return SPECULATION_NAVIGABLE;
 				}
-				case UNNAVIGABLE: {
-					switch (guardable) {
-						case HEAD: {
-							switch (phase) {
-								case PREDICATED: return PREDICATED_UNNAVIGABLE_HEAD;
-							}
-							break;
-						}
-						case STEP: {
-							switch (phase) {
-								case CONSTANT: return CONSTANT_UNNAVIGABLE_STEP;
-								case LOADED: return LOADED_UNNAVIGABLE_STEP;
-								case PREDICATED: return PREDICATED_UNNAVIGABLE_STEP;
-								case REALIZED: return REALIZED_UNNAVIGABLE_STEP;
-							}
-							break;
-						}
-					}
-					break;
+			}
+			else {
+				switch (phase) {
+					case CONSTANT: return CONSTANT_UNNAVIGABLE;
+					case LOADED: return LOADED_UNNAVIGABLE;
+					case PREDICATED: return PREDICATED_UNNAVIGABLE;
+					case REALIZED: return REALIZED_UNNAVIGABLE;
 				}
 			}
 			throw new UnsupportedOperationException();
@@ -378,47 +314,39 @@ public class Nodes
 				case CONSTANT: phase = Phase.CONSTANT; break;
 				default: throw new UnsupportedOperationException();
 			}
-			NavigableEnum navigableEnum = Nodes.asNavigable(sourceNode.isNavigable());
-			return getPatternNodeRole(phase, navigableEnum, HeadableEnum.STEP);
+			return getPatternNodeRole(phase, sourceNode.isNavigable());
 		}
 
-		private final @NonNull NavigableEnum navigable;
-		private final @NonNull HeadableEnum guardable;
+		private final boolean isNavigable;
 
-		private PatternNodeRole(@NonNull Phase phase, @NonNull NavigableEnum navigable, @NonNull HeadableEnum guardable) {
+		private PatternNodeRole(@NonNull Phase phase, boolean isNavigable) {
 			super(phase);
-			this.navigable = navigable;
-			this.guardable = guardable;
+			this.isNavigable = isNavigable;
 		}
 
 		@Override
 		public @NonNull NodeRole asNavigable() {
-			return getPatternNodeRole(phase, NavigableEnum.NAVIGABLE, guardable);
+			return getPatternNodeRole(phase, true);
 		}
 
 		@Override
 		public @NonNull PatternNodeRole asPhase(@NonNull Phase phase) {
-			return getPatternNodeRole(phase, navigable, guardable);
+			return getPatternNodeRole(phase, isNavigable);
 		}
 
 		@Override
 		public @NonNull NodeRole asSpeculated() {
-			return getPatternNodeRole(Phase.SPECULATED, NavigableEnum.NAVIGABLE, HeadableEnum.HEAD);
+			return getPatternNodeRole(Phase.SPECULATED, true);
 		}
 
 		@Override
 		public @NonNull NodeRole asSpeculation() {
-			return getPatternNodeRole(Phase.SPECULATION, NavigableEnum.NAVIGABLE, guardable);
-		}
-
-		@Override
-		public boolean isHead() {
-			return guardable == HeadableEnum.HEAD;
+			return getPatternNodeRole(Phase.SPECULATION, true);
 		}
 
 		@Override
 		public boolean isNavigable() {
-			return navigable == NavigableEnum.NAVIGABLE;
+			return isNavigable;
 		}
 
 		@Override
@@ -430,32 +358,19 @@ public class Nodes
 		public @NonNull NodeRole merge(@NonNull NodeRole nodeRole) {
 			assert nodeRole instanceof PatternNodeRole;
 			Phase mergedPhase = RegionUtil.mergeToMoreKnownPhase(this, nodeRole).getPhase();
-			NavigableEnum mergedNavigable;
-			HeadableEnum mergedGuardable;
+			boolean mergedNavigable;
 			if (mergedPhase == Phase.REALIZED) {
-				mergedNavigable = NavigableEnum.UNNAVIGABLE;
-				mergedGuardable = HeadableEnum.STEP;
+				mergedNavigable = false;
 			}
 			else {
-				mergedNavigable = Nodes.asNavigable(isNavigable() || nodeRole.isNavigable());
-				mergedGuardable = (isHead() && nodeRole.isHead()) ? HeadableEnum.HEAD : HeadableEnum.STEP;
+				mergedNavigable = isNavigable() || nodeRole.isNavigable();
 			}
-			return getPatternNodeRole(mergedPhase, mergedNavigable, mergedGuardable);
-		}
-
-		@Override
-		public @NonNull NodeRole resetHead() {
-			return getPatternNodeRole(phase, navigable, HeadableEnum.STEP);
-		}
-
-		@Override
-		public @NonNull NodeRole setHead() {
-			return getPatternNodeRole(phase, navigable, HeadableEnum.HEAD);
+			return getPatternNodeRole(mergedPhase, mergedNavigable);
 		}
 
 		@Override
 		public String toString() {
-			return phase + (isNavigable() ? "-Navigable" : "-Unnavigable") + (isHead() ? "Head-" : "Step-") + getClass().getSimpleName();
+			return phase + (isNavigable() ? "-Navigable-" : "-Unnavigable-") + getClass().getSimpleName();
 		}
 	}
 
@@ -497,11 +412,6 @@ public class Nodes
 		}
 
 		@Override
-		public boolean isHead() {
-			return true;
-		}
-
-		@Override
 		public boolean isTrue() {
 			return true;
 		}
@@ -549,7 +459,7 @@ public class Nodes
 			case CONSTANT: phase = Role.Phase.CONSTANT; break;
 			default: throw new UnsupportedOperationException();
 		}
-		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(phase, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
+		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(phase, true);
 		Property property = QVTcoreBaseUtil.getTargetProperty(navigationAssignment);
 		//		PatternNodeRole patternNodeRole = PatternNodeRole.getDataTypeNodeRole(targetNode, property);
 		//		assert sourceNode.isClass();
@@ -571,7 +481,9 @@ public class Nodes
 
 	public static @NonNull TypedNode createExtraGuardNode(@NonNull Region region, @NonNull String name, @NonNull ClassDatumAnalysis classDatumAnalysis) {
 		ExtraGuardNodeRole extraGuardNodeRole = ExtraGuardNodeRole.getExtraGuardNodeRole();
-		return extraGuardNodeRole.createNode(region, name, classDatumAnalysis);
+		TypedNode node = extraGuardNodeRole.createNode(region, name, classDatumAnalysis);
+		node.setHead();
+		return node;
 	}
 
 	public static @NonNull Node createInputNode(@NonNull Region region, NodeRole.@NonNull Phase nodeRolePhase, @NonNull String name, @NonNull ClassDatumAnalysis classDatumAnalysis) {
@@ -584,13 +496,12 @@ public class Nodes
 	}
 
 	public static @NonNull VariableNode createLetVariableNode(@NonNull Variable letVariable, @NonNull Node inNode) {
-		NavigableEnum resolvedIsNavigable = asNavigable(inNode.isNavigable());
-		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(inNode.getNodeRole().getPhase(), resolvedIsNavigable, HeadableEnum.STEP);
+		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(inNode.getNodeRole().getPhase(), inNode.isNavigable());
 		return patternNodeRole.createNode(inNode.getRegion(), letVariable);
 	}
 
 	public static @NonNull VariableNode createLoadedStepNode(@NonNull Region region, @NonNull VariableDeclaration stepVariable) {
-		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.LOADED, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
+		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.LOADED, true);
 		return patternNodeRole.createNode(region, stepVariable);
 	}
 
@@ -607,12 +518,12 @@ public class Nodes
 		DomainUsage domainUsage = region.getSchedulerConstants().getDomainUsage(variable);
 		boolean isEnforceable = domainUsage.isOutput() || domainUsage.isMiddle();
 		Role.Phase phase = isEnforceable ? Role.Phase.PREDICATED : Role.Phase.LOADED;
-		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(phase, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
+		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(phase, true);
 		return patternNodeRole.createNode(region, variable);
 	}
 
 	public static @NonNull TypedNode createOperationElementNode(@NonNull Region region, @NonNull String name, @NonNull ClassDatumAnalysis classDatumAnalysis, @NonNull Node sourceNode) {
-		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(sourceNode.getNodeRole().getPhase(), NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
+		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(sourceNode.getNodeRole().getPhase(), true);
 		return patternNodeRole.createNode(region, name, classDatumAnalysis);
 	}
 
@@ -623,12 +534,14 @@ public class Nodes
 	}
 
 	public static @NonNull TypedNode createOperationParameterNode(@NonNull Region region, @NonNull String name, @NonNull ClassDatumAnalysis classDatumAnalysis) {
-		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.PREDICATED, NavigableEnum.UNNAVIGABLE, HeadableEnum.HEAD);
-		return patternNodeRole.createNode(region, name, classDatumAnalysis);
+		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.PREDICATED, false);
+		TypedNode node = patternNodeRole.createNode(region, name, classDatumAnalysis);
+		node.setHead();
+		return node;
 	}
 
 	public static @NonNull TypedNode createOperationResultNode(@NonNull Region region, @NonNull String name, @NonNull ClassDatumAnalysis classDatumAnalysis, @NonNull Node sourceNode) {
-		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(sourceNode.getNodeRole().getPhase(), NavigableEnum.UNNAVIGABLE, HeadableEnum.STEP);
+		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(sourceNode.getNodeRole().getPhase(), false);
 		return patternNodeRole.createNode(region, name, classDatumAnalysis);
 	}
 
@@ -655,12 +568,12 @@ public class Nodes
 	}
 
 	public static @NonNull TypedNode createRealizedDataTypeNode(@NonNull Node sourceNode, @NonNull Property source2targetProperty) {
-		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.REALIZED, NavigableEnum.UNNAVIGABLE, HeadableEnum.STEP);
+		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.REALIZED, false);
 		return patternNodeRole.createNode(sourceNode, source2targetProperty);
 	}
 
 	public static @NonNull VariableNode createRealizedStepNode(@NonNull Region region, @NonNull Variable stepVariable) {
-		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.REALIZED, NavigableEnum.UNNAVIGABLE, HeadableEnum.STEP);
+		PatternNodeRole patternNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.REALIZED, false);
 		return patternNodeRole.createNode(region, stepVariable);
 	}
 
@@ -674,13 +587,12 @@ public class Nodes
 			isDirty = region.getSchedulerConstants().isDirty(referredProperty);
 		}
 		Role.Phase phase = sourceNode.isPredicated() || isMiddleOrOutput || isDirty ? Role.Phase.PREDICATED : Role.Phase.LOADED;
-		NavigableEnum navigableEnum = isNavigable ? NavigableEnum.NAVIGABLE : NavigableEnum.UNNAVIGABLE;
-		PatternNodeRole stepNodeRole = PatternNodeRole.getPatternNodeRole(phase, navigableEnum, HeadableEnum.STEP);
+		PatternNodeRole stepNodeRole = PatternNodeRole.getPatternNodeRole(phase, isNavigable);
 		return stepNodeRole.createNode(region, name, callExp);
 	}
 
 	public static @NonNull Node createStepNode(@NonNull Region region, @NonNull TypedNode typedNode) {
-		NodeRole stepNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.PREDICATED, NavigableEnum.NAVIGABLE, HeadableEnum.STEP);
+		NodeRole stepNodeRole = PatternNodeRole.getPatternNodeRole(Role.Phase.PREDICATED, true);
 		return stepNodeRole.createNode(region, typedNode.getName(), typedNode.getClassDatumAnalysis());
 	}
 
@@ -689,7 +601,9 @@ public class Nodes
 		org.eclipse.ocl.pivot.Class booleanType = schedulerConstants.getStandardLibrary().getBooleanType();
 		DomainUsage primitiveUsage = schedulerConstants.getDomainAnalysis().getPrimitiveUsage();
 		ClassDatumAnalysis classDatumAnalysis = schedulerConstants.getClassDatumAnalysis(booleanType, ClassUtil.nonNullState(primitiveUsage.getTypedModel(null)));
-		return TrueNodeRole.TRUE.createNode(region, "«true»", classDatumAnalysis);
+		TypedNode node = TrueNodeRole.TRUE.createNode(region, "«true»", classDatumAnalysis);
+		node.setHead();
+		return node;
 	}
 
 	public static @NonNull Node createUnknownNode(@NonNull Region region, @NonNull String name, @NonNull TypedElement typedElement) {
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/AssignmentPartition.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/AssignmentPartition.java
index 1d5d8e774..ddefcff8d 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/AssignmentPartition.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/AssignmentPartition.java
@@ -33,7 +33,7 @@ class AssignmentPartition extends AbstractPartition
 		//	The realized middle (trace) nodes become predicated head nodes.
 		//
 		for (@NonNull Node node : partitioner.getRealizedMiddleNodes()) {
-			addNode(node, node.getNodeRole().asPredicated().asNavigable().setHead());
+			addNode(node, node.getNodeRole().asPredicated().asNavigable()/*.setHead()*/);
 		}
 		//
 		//	The nodes that support identification of the realized edge are used as is.
@@ -52,7 +52,7 @@ class AssignmentPartition extends AbstractPartition
 			if (targetNodeRole.isRealized()) {
 				targetNodeRole = targetNodeRole.asPredicated().asNavigable();
 			}
-			addNode(targetNode, targetNodeRole.resetHead());
+			addNode(targetNode, targetNodeRole);
 			boolean hasPredecessor = false;
 			for (@NonNull Node sourceNode : getPredecessors(targetNode)) {
 				hasPredecessor = true;
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/RealizedPartition.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/RealizedPartition.java
index fe08ca027..e87a8c2de 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/RealizedPartition.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/RealizedPartition.java
@@ -86,7 +86,7 @@ class RealizedPartition extends AbstractPartition
 
 	private void gatherSourceNavigations(@NonNull Node targetNode, @NonNull NodeRole targetNodeRole) {
 		if (!hasNode(targetNode)) {
-			addNode(targetNode, targetNodeRole.resetHead());
+			addNode(targetNode, targetNodeRole);
 			for (@NonNull Node sourceNode : getPredecessors(targetNode)) {
 				gatherSourceNavigations(sourceNode, sourceNode.getNodeRole());
 			}
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculatedPartition.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculatedPartition.java
index b6a4b88a9..f1b27d681 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculatedPartition.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculatedPartition.java
@@ -131,7 +131,7 @@ class SpeculatedPartition extends AbstractPartition
 
 	private void gatherSourceNavigations(@NonNull Node targetNode, @NonNull NodeRole targetNodeRole) {
 		if (!hasNode(targetNode)) {
-			addNode(targetNode, targetNodeRole.resetHead());
+			addNode(targetNode, targetNodeRole);
 			if (!tracedInputNodes.contains(targetNode)) {
 				boolean hasPredecessor = false;
 				for (@NonNull Node sourceNode : getPredecessors(targetNode)) {
@@ -216,7 +216,7 @@ class SpeculatedPartition extends AbstractPartition
 		for (@NonNull Node node : partitioner.getPredicatedMiddleNodes()) {
 			NodeRole nodeRole = node.getNodeRole();
 			if (node.isPattern() && node.isClass()) {
-				nodeRole = nodeRole.resetHead().asSpeculated();
+				nodeRole = nodeRole.asSpeculated();
 			}
 			gatherSourceNavigations(node, nodeRole);
 		}
@@ -259,7 +259,7 @@ class SpeculatedPartition extends AbstractPartition
 		for (@NonNull Node node : partitioner.getRealizedMiddleNodes()) {
 			NodeRole nodeRole = node.getNodeRole();
 			if (node.isPattern() && node.isClass()) {
-				nodeRole = nodeRole.asSpeculated().asNavigable().setHead();
+				nodeRole = nodeRole.asSpeculated().asNavigable()/*.setHead()*/;
 			}
 			if (!hasNode(node)) {
 				addNode(node, nodeRole);
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculationPartition.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculationPartition.java
index f84f6388b..cf584d548 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculationPartition.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/partitioner/SpeculationPartition.java
@@ -36,7 +36,7 @@ class SpeculationPartition extends AbstractPartition
 		//
 		for (@NonNull Node node : partitioner.getRealizedMiddleNodes()) {
 			if (node.isPattern() && node.isClass()) {		// FIXME UML2RDBMS experiment
-				NodeRole speculationNodeRole = node.getNodeRole().resetHead().asSpeculation();
+				NodeRole speculationNodeRole = node.getNodeRole().asSpeculation();
 				addNode(node, speculationNodeRole);
 				for (@NonNull NavigationEdge edge : node.getNavigationEdges()) {
 					addReachableConstantOrLoadedNodes(edge.getTarget());