fix: preserve inheritance split case order

Symptom: type split cases with equivalent empty/fall-through bodies could be
reordered after describe/exec/describe.

Root cause: inheritance split case flows did not carry a stable ordering signal
when multiple cases shared the same split-to-merge shape, so the describer could
only rely on connection metadata that was identical across those branches.

Fix: encode the parsed case order into valid split flow connection pairs and
sort inheritance split flows by that encoded order during describe.

Tests: added traversal coverage for shuffled stored inheritance case flows that
must still describe in the original authoring order; existing inheritance split
builder and cast coverage continues to pass.

Author: hjothamendix

mdl/executor/cmd_microflows_builder_actions.go

@@ -458,6 +458,7 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		id        model.ID
 		caseValue string
 		fromSplit bool
+		order     int
 	}
 	var branchTails []branchTail
 
@@ -471,7 +472,7 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		branchIndex++
 		if len(body) == 0 {
 			allBranchesReturn = false
-			branchTails = append(branchTails, branchTail{id: splitID, caseValue: caseValue, fromSplit: true})
+			branchTails = append(branchTails, branchTail{id: splitID, caseValue: caseValue, fromSplit: true, order: branchNumber})
 			return
 		}
 
@@ -503,6 +504,7 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 				if caseValue == "" {
 					flow = newHorizontalFlow(splitID, actID)
 				}
+				applyInheritanceSplitCaseOrder(flow, branchNumber)
 				fb.flows = append(fb.flows, flow)
 			} else {
 				if pendingCase != "" {
@@ -554,11 +556,14 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		fb.objects = append(fb.objects, merge)
 		for _, tail := range branchTails {
 			if tail.fromSplit {
+				var flow *microflows.SequenceFlow
 				if tail.caseValue == "" {
-					fb.flows = append(fb.flows, newHorizontalFlow(splitID, merge.ID))
+					flow = newHorizontalFlow(splitID, merge.ID)
 				} else {
-					fb.flows = append(fb.flows, newDownwardFlowWithInheritanceCase(splitID, merge.ID, tail.caseValue))
+					flow = newDownwardFlowWithInheritanceCase(splitID, merge.ID, tail.caseValue)
 				}
+				applyInheritanceSplitCaseOrder(flow, tail.order)
+				fb.flows = append(fb.flows, flow)
 			} else {
 				if tail.caseValue != "" {
 					fb.flows = append(fb.flows, newHorizontalFlowWithCase(tail.id, merge.ID, tail.caseValue))
@@ -664,6 +669,39 @@ func appendInheritanceBodies(s *ast.InheritanceSplitStmt) []ast.MicroflowStateme
 	return stmts
 }
 
+type inheritanceSplitCaseOrderAnchor struct {
+	origin      int
+	destination int
+}
+
+var inheritanceSplitCaseOrderAnchors = []inheritanceSplitCaseOrderAnchor{
+	{AnchorTop, AnchorLeft},
+	{AnchorRight, AnchorLeft},
+	{AnchorBottom, AnchorLeft},
+	{AnchorLeft, AnchorLeft},
+	{AnchorTop, AnchorTop},
+	{AnchorRight, AnchorTop},
+	{AnchorBottom, AnchorTop},
+	{AnchorLeft, AnchorTop},
+	{AnchorTop, AnchorRight},
+	{AnchorRight, AnchorRight},
+	{AnchorBottom, AnchorRight},
+	{AnchorLeft, AnchorRight},
+	{AnchorTop, AnchorBottom},
+	{AnchorRight, AnchorBottom},
+	{AnchorBottom, AnchorBottom},
+	{AnchorLeft, AnchorBottom},
+}
+
+func applyInheritanceSplitCaseOrder(flow *microflows.SequenceFlow, order int) {
+	if flow == nil || order < 0 || order >= len(inheritanceSplitCaseOrderAnchors) {
+		return
+	}
+	pair := inheritanceSplitCaseOrderAnchors[order]
+	flow.OriginConnectionIndex = pair.origin
+	flow.DestinationConnectionIndex = pair.destination
+}
+
 func qualifiedNameString(qn ast.QualifiedName) string {
 	if qn.Module == "" {
 		return qn.Name

mdl/executor/cmd_microflows_inheritance_test.go

@@ -3,6 +3,7 @@
 package executor
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/mendixlabs/mxcli/mdl/ast"
@@ -116,6 +117,39 @@ func TestTraverseFlow_InheritanceSplit(t *testing.T) {
 	assertLineContains(t, lines, "end split;")
 }
 
+func TestTraverseFlow_InheritanceSplitPreservesExplicitCaseOrder(t *testing.T) {
+	e := newTestExecutor()
+	activityMap := map[model.ID]microflows.MicroflowObject{
+		mkID("split"): &microflows.InheritanceSplit{
+			BaseMicroflowObject: mkObj("split"),
+			VariableName:        "Input",
+		},
+		mkID("merge"): &microflows.ExclusiveMerge{BaseMicroflowObject: mkObj("merge")},
+	}
+	accountFlow := mkBranchFlow("split", "merge", &microflows.InheritanceCase{EntityQualifiedName: "Sample.Account"})
+	userFlow := mkBranchFlow("split", "merge", &microflows.InheritanceCase{EntityQualifiedName: "Sample.User"})
+	applyInheritanceSplitCaseOrder(accountFlow, 0)
+	applyInheritanceSplitCaseOrder(userFlow, 1)
+	flowsByOrigin := map[model.ID][]*microflows.SequenceFlow{
+		mkID("split"): {userFlow, accountFlow},
+	}
+	splitMergeMap := map[model.ID]model.ID{mkID("split"): mkID("merge")}
+
+	var lines []string
+	visited := make(map[model.ID]bool)
+	e.traverseFlow(mkID("split"), activityMap, flowsByOrigin, splitMergeMap, visited, nil, nil, &lines, 1, nil, 0, nil)
+
+	out := strings.Join(lines, "\n")
+	accountIdx := strings.Index(out, "case Sample.Account")
+	userIdx := strings.Index(out, "case Sample.User")
+	if accountIdx == -1 || userIdx == -1 {
+		t.Fatalf("missing expected cases:\n%s", out)
+	}
+	if accountIdx > userIdx {
+		t.Fatalf("case order was not preserved:\n%s", out)
+	}
+}
+
 func TestLastStmtIsReturn_InheritanceSplitAllBranchesReturn(t *testing.T) {
 	body := []ast.MicroflowStatement{
 		&ast.InheritanceSplitStmt{

mdl/executor/cmd_microflows_show_helpers.go

@@ -1302,7 +1302,7 @@ func emitInheritanceSplitStatement(
 	*lines = append(*lines, indentStr+"split type "+varName)
 
 	var elseFlow *microflows.SequenceFlow
-	for _, flow := range findNormalFlows(flowsByOrigin[currentID]) {
+	for _, flow := range orderedInheritanceSplitFlows(findNormalFlows(flowsByOrigin[currentID])) {
 		caseName, ok := inheritanceCaseName(flow, entityNames)
 		if !ok {
 			elseFlow = flow
@@ -1387,6 +1387,14 @@ func orderedEnumSplitFlows(flows []*microflows.SequenceFlow) []*microflows.Seque
 	return ordered
 }
 
+func orderedInheritanceSplitFlows(flows []*microflows.SequenceFlow) []*microflows.SequenceFlow {
+	ordered := append([]*microflows.SequenceFlow(nil), flows...)
+	sort.SliceStable(ordered, func(i, j int) bool {
+		return inheritanceSplitCaseOrder(ordered[i]) < inheritanceSplitCaseOrder(ordered[j])
+	})
+	return ordered
+}
+
 func splitCaseOrder(flow *microflows.SequenceFlow) int {
 	if flow == nil {
 		return 1 << 20
@@ -1399,6 +1407,18 @@ func splitCaseOrder(flow *microflows.SequenceFlow) int {
 	return (1 << 10) + flow.OriginConnectionIndex*4 + flow.DestinationConnectionIndex
 }
 
+func inheritanceSplitCaseOrder(flow *microflows.SequenceFlow) int {
+	if flow == nil {
+		return 1 << 20
+	}
+	for i, pair := range inheritanceSplitCaseOrderAnchors {
+		if flow.OriginConnectionIndex == pair.origin && flow.DestinationConnectionIndex == pair.destination {
+			return i
+		}
+	}
+	return (1 << 10) + flow.OriginConnectionIndex*4 + flow.DestinationConnectionIndex
+}
+
 func formatEnumSplitCaseValue(value string) string {
 	if value == "" || value == "(empty)" {
 		return "(empty)"