fix: preserve enum split roundtrip validity

Symptom: enum-based microflow dispatchers described as boolean IFs, duplicated
shared continuation tails inside each case, or rebuilt grouped enum flows with
invalid Studio Pro topology.

Root cause: the MDL AST, parser, describer, and builder had no explicit enum
split representation. Split pairing also required every branch to reach the same
join, so a terminal enum case prevented shared non-terminal tails from being
emitted once after the split.

Fix: add `split enum` parsing, formatting, validation, and graph building;
preserve grouped enum cases through valid intermediate merges; treat exhaustive
terminal enum splits as terminating; keep repeated call-output declarations
branch-local; and let split pairing select a partial shared join when all
non-reaching branches terminate before it.

Tests: make build; make test; targeted Control Center audit
`targeted-structural-enum-partial-join-20260426T203027Z` returned 8 match, 0
discrepancies, and clean Mendix mx check results.

Author: hjothamendix

mdl/ast/ast_microflow.go

@@ -95,6 +95,23 @@ type InheritanceSplitStmt struct {
 
 func (s *InheritanceSplitStmt) isMicroflowStatement() {}
 
+// EnumSplitCase represents one enumeration branch in an EnumSplit.
+type EnumSplitCase struct {
+	Value  string   // First enumeration value, or "(empty)" for Mendix's empty enum case.
+	Values []string // All enumeration values that share this branch.
+	Body   []MicroflowStatement
+}
+
+// EnumSplitStmt represents: SPLIT ENUM $Var ... END SPLIT
+type EnumSplitStmt struct {
+	Variable    string // Variable or attribute path without $ prefix (e.g. EventType or Event/EventType)
+	Cases       []EnumSplitCase
+	ElseBody    []MicroflowStatement
+	Annotations *ActivityAnnotations // Optional @position, @caption, @color, @annotation
+}
+
+func (s *EnumSplitStmt) isMicroflowStatement() {}
+
 // CastObjectStmt represents: $Output = CAST $Object
 type CastObjectStmt struct {
 	OutputVariable string               // Output variable name (without $ prefix)

mdl/executor/cmd_diff_mdl.go

@@ -337,6 +337,22 @@ func microflowStatementToMDL(ctx *ExecContext, stmt ast.MicroflowStatement, inde
 		}
 		lines = append(lines, indentStr+"end if;")
 
+	case *ast.EnumSplitStmt:
+		lines = append(lines, fmt.Sprintf("%ssplit enum $%s", indentStr, s.Variable))
+		for _, branch := range s.Cases {
+			lines = append(lines, fmt.Sprintf("%scase %s", indentStr, formatEnumSplitCaseValues(enumSplitCaseValues(branch))))
+			for _, branchStmt := range branch.Body {
+				lines = append(lines, microflowStatementToMDL(ctx, branchStmt, indent+1)...)
+			}
+		}
+		if len(s.ElseBody) > 0 {
+			lines = append(lines, indentStr+"else")
+			for _, elseStmt := range s.ElseBody {
+				lines = append(lines, microflowStatementToMDL(ctx, elseStmt, indent+1)...)
+			}
+		}
+		lines = append(lines, indentStr+"end split;")
+
 	case *ast.LoopStmt:
 		lines = append(lines, fmt.Sprintf("%sloop $%s in $%s", indentStr, s.LoopVariable, s.ListVariable))
 		for _, bodyStmt := range s.Body {

mdl/executor/cmd_microflows_builder_actions.go

@@ -259,6 +259,298 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 	return splitID
 }
 
+func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
+	splitX := fb.posX
+	centerY := fb.posY
+	split := &microflows.ExclusiveSplit{
+		BaseMicroflowObject: microflows.BaseMicroflowObject{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Position:    model.Point{X: splitX, Y: centerY},
+			Size:        model.Size{Width: SplitWidth, Height: SplitHeight},
+		},
+		Caption: "$" + s.Variable,
+		SplitCondition: &microflows.ExpressionSplitCondition{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Expression:  "$" + s.Variable,
+		},
+		ErrorHandlingType: microflows.ErrorHandlingTypeRollback,
+	}
+	fb.objects = append(fb.objects, split)
+
+	splitID := split.ID
+	if fb.pendingAnnotations != nil {
+		fb.applyAnnotations(splitID, fb.pendingAnnotations)
+		fb.pendingAnnotations = nil
+	}
+
+	savedEndsWithReturn := fb.endsWithReturn
+	fb.endsWithReturn = false
+	allBranchesReturn := len(s.Cases) > 0 || len(s.ElseBody) > 0
+	branchStartX := splitX + SplitWidth + HorizontalSpacing/2
+	branchIndex := 0
+	type branchTail struct {
+		id        model.ID
+		values    []string
+		fromSplit bool
+	}
+	var branchTails []branchTail
+	routePendingErrorToElse := len(s.ElseBody) > 0 && fb.errorHandlerSkipVar != "" && s.Variable == fb.errorHandlerSkipVar
+	pendingErrorForElse := pendingErrorHandlerState{}
+
+	addBranch := func(values []string, body []ast.MicroflowStatement) {
+		branchNumber := branchIndex
+		branchY := centerY + branchNumber*VerticalSpacing
+		branchIndex++
+		if len(body) == 0 {
+			allBranchesReturn = false
+			branchTails = append(branchTails, branchTail{id: splitID, values: values, fromSplit: true})
+			return
+		}
+
+		fb.posX = branchStartX
+		fb.posY = branchY
+		fb.endsWithReturn = false
+		branchEntryID := splitID
+		branchEntryIsSplit := true
+		if len(values) > 1 {
+			branchMerge := &microflows.ExclusiveMerge{
+				BaseMicroflowObject: microflows.BaseMicroflowObject{
+					BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+					Position:    model.Point{X: branchStartX, Y: branchY},
+					Size:        model.Size{Width: MergeSize, Height: MergeSize},
+				},
+			}
+			fb.objects = append(fb.objects, branchMerge)
+			for i, value := range values {
+				var flow *microflows.SequenceFlow
+				if enumSplitUsesHorizontalOrigin(values) {
+					flow = newHorizontalFlowWithEnumCase(splitID, branchMerge.ID, value)
+				} else {
+					flow = newDownwardFlowWithEnumCase(splitID, branchMerge.ID, value)
+				}
+				if i > 0 {
+					flow.DestinationConnectionIndex = enumSplitGroupedDestinationAnchor(AnchorLeft, i)
+				}
+				applyEnumGroupedControlVectors(flow, i, len(values))
+				fb.flows = append(fb.flows, flow)
+			}
+			branchEntryID = branchMerge.ID
+			branchEntryIsSplit = false
+			fb.posX = branchStartX + HorizontalSpacing/2
+		}
+
+		var lastID model.ID
+		var prevAnchor *ast.FlowAnchors
+		var pendingCase string
+		var pendingAnchor *ast.FlowAnchors
+		for i, stmt := range body {
+			thisAnchor := stmtOwnAnchor(stmt)
+			actID := fb.addStatement(stmt)
+			if actID == "" {
+				continue
+			}
+			fb.applyPendingAnnotations(actID)
+			if lastID == "" {
+				var flow *microflows.SequenceFlow
+				if branchEntryIsSplit {
+					if enumSplitUsesHorizontalOrigin(values) {
+						flow = newHorizontalFlowWithEnumCase(splitID, actID, enumSplitFlowCaseValue(values, 0))
+					} else {
+						flow = newDownwardFlowWithEnumCase(splitID, actID, enumSplitFlowCaseValue(values, 0))
+					}
+				} else {
+					flow = newHorizontalFlow(branchEntryID, actID)
+				}
+				if thisAnchor != nil && thisAnchor.To != ast.AnchorSideUnset {
+					flow.DestinationConnectionIndex = int(thisAnchor.To)
+				}
+				baseDestinationAnchor := flow.DestinationConnectionIndex
+				if branchEntryIsSplit {
+					applyEnumGroupedControlVectors(flow, 0, len(values))
+				}
+				fb.flows = append(fb.flows, flow)
+				if branchEntryIsSplit {
+					for i := 1; i < len(values); i++ {
+						var extraFlow *microflows.SequenceFlow
+						if enumSplitUsesHorizontalOrigin(values) {
+							extraFlow = newHorizontalFlowWithEnumCase(splitID, actID, values[i])
+						} else {
+							extraFlow = newDownwardFlowWithEnumCase(splitID, actID, values[i])
+						}
+						if thisAnchor != nil && thisAnchor.To != ast.AnchorSideUnset {
+							extraFlow.DestinationConnectionIndex = int(thisAnchor.To)
+						}
+						extraFlow.DestinationConnectionIndex = enumSplitGroupedDestinationAnchor(baseDestinationAnchor, i)
+						applyEnumGroupedControlVectors(extraFlow, i, len(values))
+						fb.flows = append(fb.flows, extraFlow)
+					}
+				}
+				if routePendingErrorToElse && len(values) == 0 {
+					fb.routePendingErrorHandlerToAlternative(splitID, actID)
+				}
+				fb.addPendingErrorHandlerFlowForStatement(flow.OriginID, flow.DestinationID, stmt, statementsReferenceVar(body[i+1:], fb.errorHandlerSkipVar))
+			} else {
+				var flow *microflows.SequenceFlow
+				originAnchor := prevAnchor
+				destAnchor := thisAnchor
+				if pendingCase != "" {
+					flow = newHorizontalFlowWithCase(lastID, actID, pendingCase)
+					originAnchor, destAnchor = pendingFlowAnchors(prevAnchor, pendingAnchor, thisAnchor)
+					pendingCase = ""
+					pendingAnchor = nil
+				} else {
+					flow = newHorizontalFlow(lastID, actID)
+				}
+				applyUserAnchors(flow, originAnchor, destAnchor)
+				fb.flows = append(fb.flows, flow)
+				fb.addPendingErrorHandlerFlowForStatement(flow.OriginID, flow.DestinationID, stmt, statementsReferenceVar(body[i+1:], fb.errorHandlerSkipVar))
+			}
+			prevAnchor = thisAnchor
+			if fb.nextConnectionPoint != "" {
+				lastID = fb.nextConnectionPoint
+				fb.nextConnectionPoint = ""
+				pendingCase = fb.nextFlowCase
+				fb.nextFlowCase = ""
+				pendingAnchor = fb.nextFlowAnchor
+				fb.nextFlowAnchor = nil
+			} else {
+				lastID = actID
+			}
+		}
+		if !lastStmtIsReturn(body) {
+			allBranchesReturn = false
+			if lastID != "" {
+				branchTails = append(branchTails, branchTail{id: lastID})
+			}
+		}
+	}
+
+	if routePendingErrorToElse {
+		pendingErrorForElse = fb.capturePendingErrorHandler()
+		fb.clearPendingErrorHandler()
+	}
+	for _, c := range s.Cases {
+		addBranch(enumSplitCaseValues(c), c.Body)
+	}
+	if routePendingErrorToElse && fb.capturePendingErrorHandler().isEmpty() {
+		fb.restorePendingErrorHandler(pendingErrorForElse)
+	}
+	if len(s.ElseBody) > 0 {
+		addBranch(nil, s.ElseBody)
+	}
+
+	fb.posX = branchStartX + fb.measurer.measureStatements(appendEnumBodies(s)).Width + HorizontalSpacing/2
+	fb.posY = centerY
+	fb.endsWithReturn = savedEndsWithReturn
+	if allBranchesReturn {
+		fb.endsWithReturn = true
+	} else if len(branchTails) == 1 && !branchTails[0].fromSplit {
+		fb.nextConnectionPoint = branchTails[0].id
+	} else if len(branchTails) > 0 {
+		merge := &microflows.ExclusiveMerge{
+			BaseMicroflowObject: microflows.BaseMicroflowObject{
+				BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+				Position:    model.Point{X: fb.posX, Y: centerY},
+				Size:        model.Size{Width: MergeSize, Height: MergeSize},
+			},
+		}
+		fb.objects = append(fb.objects, merge)
+		for _, tail := range branchTails {
+			if tail.fromSplit {
+				var flow *microflows.SequenceFlow
+				if enumSplitUsesHorizontalOrigin(tail.values) {
+					flow = newHorizontalFlowWithEnumCase(splitID, merge.ID, enumSplitFlowCaseValue(tail.values, 0))
+				} else {
+					flow = newDownwardFlowWithEnumCase(splitID, merge.ID, enumSplitFlowCaseValue(tail.values, 0))
+				}
+				baseDestinationAnchor := flow.DestinationConnectionIndex
+				applyEnumGroupedControlVectors(flow, 0, len(tail.values))
+				fb.flows = append(fb.flows, flow)
+				for i := 1; i < len(tail.values); i++ {
+					var extraFlow *microflows.SequenceFlow
+					if enumSplitUsesHorizontalOrigin(tail.values) {
+						extraFlow = newHorizontalFlowWithEnumCase(splitID, merge.ID, tail.values[i])
+					} else {
+						extraFlow = newDownwardFlowWithEnumCase(splitID, merge.ID, tail.values[i])
+					}
+					extraFlow.DestinationConnectionIndex = enumSplitGroupedDestinationAnchor(baseDestinationAnchor, i)
+					applyEnumGroupedControlVectors(extraFlow, i, len(tail.values))
+					fb.flows = append(fb.flows, extraFlow)
+				}
+			} else {
+				fb.flows = append(fb.flows, newHorizontalFlow(tail.id, merge.ID))
+			}
+		}
+		fb.nextConnectionPoint = merge.ID
+	}
+	return splitID
+}
+
+func enumSplitCaseValues(c ast.EnumSplitCase) []string {
+	if len(c.Values) > 0 {
+		return append([]string(nil), c.Values...)
+	}
+	if c.Value != "" {
+		return []string{c.Value}
+	}
+	return nil
+}
+
+func enumSplitFlowCaseValue(values []string, index int) string {
+	if index >= 0 && index < len(values) {
+		return values[index]
+	}
+	return ""
+}
+
+func enumSplitUsesHorizontalOrigin(values []string) bool {
+	return len(values) > 0 && values[0] != "" && values[0] != "(empty)"
+}
+
+func enumSplitGroupedDestinationAnchor(baseAnchor, index int) int {
+	if index == 0 {
+		return baseAnchor
+	}
+	offset := 0
+	for _, candidate := range []int{AnchorTop, AnchorBottom, AnchorRight, AnchorLeft} {
+		if candidate == baseAnchor {
+			continue
+		}
+		if offset == index-1 {
+			return candidate
+		}
+		offset++
+	}
+	return baseAnchor
+}
+
+func applyEnumGroupedControlVectors(flow *microflows.SequenceFlow, index, total int) {
+	if flow == nil || total == 0 {
+		return
+	}
+	switch {
+	case flow.OriginConnectionIndex == AnchorRight && flow.DestinationConnectionIndex == AnchorLeft:
+		flow.OriginControlVector = "15;0"
+		if total > 1 {
+			flow.DestinationControlVector = "-15;0"
+		} else {
+			flow.DestinationControlVector = "-30;0"
+		}
+	case flow.OriginConnectionIndex == AnchorRight && flow.DestinationConnectionIndex == AnchorTop:
+		flow.OriginControlVector = "0;-95"
+		flow.DestinationControlVector = "15;-45"
+	case flow.OriginConnectionIndex == AnchorRight && flow.DestinationConnectionIndex == AnchorBottom:
+		flow.OriginControlVector = "0;95"
+		flow.DestinationControlVector = "15;45"
+	case flow.OriginConnectionIndex == AnchorBottom && flow.DestinationConnectionIndex == AnchorTop:
+		flow.OriginControlVector = "0;15"
+		flow.DestinationControlVector = "0;-30"
+	case index > 0:
+		flow.OriginControlVector = "15;0"
+		flow.DestinationControlVector = "-15;0"
+	}
+}
+
 func appendInheritanceBodies(s *ast.InheritanceSplitStmt) []ast.MicroflowStatement {
 	var stmts []ast.MicroflowStatement
 	for _, c := range s.Cases {
@@ -268,6 +560,15 @@ func appendInheritanceBodies(s *ast.InheritanceSplitStmt) []ast.MicroflowStateme
 	return stmts
 }
 
+func appendEnumBodies(s *ast.EnumSplitStmt) []ast.MicroflowStatement {
+	var stmts []ast.MicroflowStatement
+	for _, c := range s.Cases {
+		stmts = append(stmts, c.Body...)
+	}
+	stmts = append(stmts, s.ElseBody...)
+	return stmts
+}
+
 func qualifiedNameString(qn ast.QualifiedName) string {
 	if qn.Module == "" {
 		return qn.Name

mdl/executor/cmd_microflows_builder_annotations.go

@@ -17,6 +17,8 @@ func getStatementAnnotations(stmt ast.MicroflowStatement) *ast.ActivityAnnotatio
 		return s.Annotations
 	case *ast.InheritanceSplitStmt:
 		return s.Annotations
+	case *ast.EnumSplitStmt:
+		return s.Annotations
 	case *ast.CastObjectStmt:
 		return s.Annotations
 	case *ast.MfSetStmt: