fix: preserve inheritance split branch anchors

Symptom: inheritance split roundtrips could lose branch flow anchors or collapse an explicit empty ELSE branch into an untyped flow.

Root cause: inheritance branch building did not thread statement anchor metadata through split-to-body and body-to-merge flows, and empty ELSE tails used a plain sequence flow instead of an explicit inheritance case.

Fix: propagate authored branch anchors across inheritance branch body flows and keep empty ELSE branches represented by an explicit empty InheritanceCase.

Tests: added builder coverage for anchored inheritance branch bodies and tightened the existing case-flow assertion to select the intended typed branch.

Author: hjothamendix

mdl/executor/cmd_microflows_builder_actions.go

@@ -459,6 +459,7 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		caseValue string
 		fromSplit bool
 		order     int
+		anchor    *ast.FlowAnchors
 	}
 	var branchTails []branchTail
 
@@ -481,8 +482,10 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		fb.endsWithReturn = false
 
 		var lastID model.ID
+		var prevAnchor *ast.FlowAnchors
 		pendingCase := ""
 		for _, stmt := range body {
+			thisAnchor := stmtOwnAnchor(stmt)
 			actID := fb.addStatement(stmt)
 			if actID == "" {
 				continue
@@ -501,19 +504,21 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 				} else {
 					flow = newDownwardFlowWithInheritanceCase(splitID, actID, caseValue)
 				}
-				if caseValue == "" {
-					flow = newHorizontalFlow(splitID, actID)
-				}
-				applyInheritanceSplitCaseOrder(flow, branchNumber)
+				applyUserAnchors(flow, nil, thisAnchor)
 				fb.flows = append(fb.flows, flow)
 			} else {
 				if pendingCase != "" {
-					fb.flows = append(fb.flows, newHorizontalFlowWithCase(lastID, actID, pendingCase))
+					flow := newHorizontalFlowWithCase(lastID, actID, pendingCase)
+					applyUserAnchors(flow, prevAnchor, thisAnchor)
+					fb.flows = append(fb.flows, flow)
 					pendingCase = ""
 				} else {
-					fb.flows = append(fb.flows, newHorizontalFlow(lastID, actID))
+					flow := newHorizontalFlow(lastID, actID)
+					applyUserAnchors(flow, prevAnchor, thisAnchor)
+					fb.flows = append(fb.flows, flow)
 				}
 			}
+			prevAnchor = thisAnchor
 			if fb.nextConnectionPoint != "" {
 				lastID = fb.nextConnectionPoint
 				fb.nextConnectionPoint = ""
@@ -527,7 +532,7 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		if !lastStmtIsReturn(body) {
 			allBranchesReturn = false
 			if lastID != "" {
-				branchTails = append(branchTails, branchTail{id: lastID, caseValue: pendingCase})
+				branchTails = append(branchTails, branchTail{id: lastID, caseValue: pendingCase, anchor: prevAnchor})
 			}
 		}
 	}
@@ -557,18 +562,22 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		for _, tail := range branchTails {
 			if tail.fromSplit {
 				var flow *microflows.SequenceFlow
-				if tail.caseValue == "" {
-					flow = newHorizontalFlow(splitID, merge.ID)
+				if tail.order == 0 {
+					flow = newHorizontalFlowWithInheritanceCase(splitID, merge.ID, tail.caseValue)
 				} else {
 					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))
+					flow := newHorizontalFlowWithCase(tail.id, merge.ID, tail.caseValue)
+					applyUserAnchors(flow, tail.anchor, nil)
+					fb.flows = append(fb.flows, flow)
 				} else {
-					fb.flows = append(fb.flows, newHorizontalFlow(tail.id, merge.ID))
+					flow := newHorizontalFlow(tail.id, merge.ID)
+					applyUserAnchors(flow, tail.anchor, nil)
+					fb.flows = append(fb.flows, flow)
 				}
 			}
 		}

mdl/executor/cmd_microflows_inheritance_test.go

@@ -57,7 +57,7 @@ func TestBuilder_InheritanceSplitAndCastAction(t *testing.T) {
 	}
 	for _, flow := range oc.Flows {
 		if split != nil && flow.OriginID == split.ID {
-			if _, ok := flow.CaseValue.(*microflows.InheritanceCase); ok {
+			if caseValue, ok := flow.CaseValue.(*microflows.InheritanceCase); ok && caseValue.EntityQualifiedName == "Sample.SpecializedInput" {
 				caseFlow = flow
 			}
 		}
@@ -230,6 +230,89 @@ func TestBuilder_InheritanceSplitNestedEmptyThenBranchKeepsContinuationCase(t *t
 	t.Fatal("nested empty-then inheritance branch must carry CaseValue=true to the inheritance merge")
 }
 
+func TestBuilder_InheritanceSplitBranchAnchorsApplyToBodyFlows(t *testing.T) {
+	fb := &flowBuilder{spacing: HorizontalSpacing, measurer: &layoutMeasurer{}}
+	message := &ast.ShowMessageStmt{
+		Message: &ast.LiteralExpr{Kind: ast.LiteralString, Value: "No matching account"},
+		Type:    "Information",
+		Annotations: &ast.ActivityAnnotations{
+			Anchor: &ast.FlowAnchors{From: ast.AnchorSideBottom, To: ast.AnchorSideTop},
+		},
+	}
+	bodyReturn := &ast.ReturnStmt{
+		Annotations: &ast.ActivityAnnotations{
+			Anchor: &ast.FlowAnchors{From: ast.AnchorSideUnset, To: ast.AnchorSideTop},
+		},
+	}
+
+	oc := fb.buildFlowGraph([]ast.MicroflowStatement{
+		&ast.InheritanceSplitStmt{
+			Variable: "Input",
+			Cases: []ast.InheritanceSplitCase{
+				{
+					Entity: ast.QualifiedName{Module: "Sample", Name: "Primary"},
+					Body:   []ast.MicroflowStatement{&ast.ReturnStmt{}},
+				},
+				{
+					Entity: ast.QualifiedName{Module: "Sample", Name: "Secondary"},
+					Body:   []ast.MicroflowStatement{message, bodyReturn},
+				},
+			},
+			ElseBody: []ast.MicroflowStatement{&ast.ReturnStmt{}},
+		},
+	}, nil)
+
+	var splitID, messageID model.ID
+	for _, obj := range oc.Objects {
+		switch obj := obj.(type) {
+		case *microflows.InheritanceSplit:
+			splitID = obj.ID
+		case *microflows.ActionActivity:
+			if _, ok := obj.Action.(*microflows.ShowMessageAction); ok {
+				messageID = obj.ID
+			}
+		}
+	}
+	if splitID == "" || messageID == "" {
+		t.Fatalf("expected split and show-message activity, got split=%q message=%q", splitID, messageID)
+	}
+
+	var splitToMessage, messageToReturn *microflows.SequenceFlow
+	var elseCase *microflows.InheritanceCase
+	for _, flow := range oc.Flows {
+		if flow.OriginID == splitID && flow.DestinationID == messageID {
+			splitToMessage = flow
+		}
+		if flow.OriginID == messageID {
+			messageToReturn = flow
+		}
+		if flow.OriginID == splitID {
+			if c, ok := flow.CaseValue.(*microflows.InheritanceCase); ok && c.EntityQualifiedName == "" {
+				elseCase = c
+			}
+		}
+	}
+	if splitToMessage == nil {
+		t.Fatal("expected inheritance split flow to annotated branch body")
+	}
+	if splitToMessage.OriginConnectionIndex != AnchorBottom || splitToMessage.DestinationConnectionIndex != AnchorTop {
+		t.Fatalf("split branch anchors = (%d,%d), want (%d,%d)",
+			splitToMessage.OriginConnectionIndex, splitToMessage.DestinationConnectionIndex,
+			AnchorBottom, AnchorTop)
+	}
+	if messageToReturn == nil {
+		t.Fatal("expected message to return flow")
+	}
+	if messageToReturn.OriginConnectionIndex != AnchorBottom || messageToReturn.DestinationConnectionIndex != AnchorTop {
+		t.Fatalf("body flow anchors = (%d,%d), want (%d,%d)",
+			messageToReturn.OriginConnectionIndex, messageToReturn.DestinationConnectionIndex,
+			AnchorBottom, AnchorTop)
+	}
+	if elseCase == nil {
+		t.Fatal("expected ELSE branch to keep an explicit empty inheritance case")
+	}
+}
+
 func assertLineContains(t *testing.T, lines []string, want string) {
 	t.Helper()
 	for _, line := range lines {