Merge pull request #460 from hjotha/submit/merged-pr-review-followups-2

fix: address merged microflow review follow-ups

Author: ako

mdl-examples/doctype-tests/02-microflow-examples.mdl

@@ -671,6 +671,28 @@ begin
 end;
 /
 
+/**
+ * Example 6.1b: LOOP with custom caption
+ *
+ * Demonstrates activity metadata on a loop.
+ */
+create microflow MfTest.M021_2_LoopWithCaption (
+  $ProductList: list of MfTest.Product
+)
+returns integer as $count
+begin
+  declare $count integer = 0;
+
+  @caption 'Process products'
+  loop $Product in $ProductList
+  begin
+    set $count = $count + 1;
+  end loop;
+
+  return $count;
+end;
+/
+
 /**
  * Example 6.2: LOOP with object modification
  *

mdl/executor/cmd_microflows_builder_actions.go

@@ -272,9 +272,8 @@ func (fb *flowBuilder) addChangeObjectAction(s *ast.ChangeObjectStmt) model.ID {
 }
 
 func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
-	if len(s.Cases) > len(splitCaseOrderAnchors) {
-		fb.addError("case statement on '$%s' has %d cases; maximum supported is %d",
-			s.Variable, len(s.Cases), len(splitCaseOrderAnchors))
+	if count := enumSplitBranchCount(s); count > maxEnumSplitBranches {
+		fb.addError("enum split has %d branches; at most %d branches are supported", count, maxEnumSplitBranches)
 		return ""
 	}
 
@@ -346,7 +345,9 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 
 		lastID := model.ID("")
 		pendingCase := ""
+		var prevAnchor *ast.FlowAnchors
 		for _, stmt := range br.body {
+			thisAnchor := stmtOwnAnchor(stmt)
 			actID := fb.addStatement(stmt)
 			if actID == "" {
 				continue
@@ -357,14 +358,26 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 			}
 			if lastID == "" {
 				fb.addGroupedEnumSplitFlows(splitID, actID, br.values, i, splitX+SplitWidth+HorizontalSpacing/4, branchY)
+				// The first statement in a case can carry @anchor(from:…,
+				// to:…) that should apply to the split→firstActivity flow.
+				// addGroupedEnumSplitFlows appends one flow per case value;
+				// anchor the last one so `@anchor(to: top)` etc. round-trips
+				// through describe → exec without silently dropping.
+				if thisAnchor != nil && len(fb.flows) > 0 {
+					applyUserAnchors(fb.flows[len(fb.flows)-1], nil, thisAnchor)
+				}
 			} else {
+				var flow *microflows.SequenceFlow
 				if pendingCase != "" {
-					fb.flows = append(fb.flows, newHorizontalFlowWithCase(lastID, actID, pendingCase))
+					flow = newHorizontalFlowWithCase(lastID, actID, pendingCase)
 					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 = ""
@@ -456,6 +469,8 @@ var splitCaseOrderAnchors = []splitCaseOrderAnchor{
 	{AnchorLeft, AnchorBottom},
 }
 
+var maxEnumSplitBranches = len(splitCaseOrderAnchors)
+
 func applySplitCaseOrder(flow *microflows.SequenceFlow, order int) {
 	if flow == nil || order < 0 || order >= len(splitCaseOrderAnchors) {
 		return
@@ -475,6 +490,17 @@ func enumSplitCaseValues(c ast.EnumSplitCase) []string {
 	return nil
 }
 
+func enumSplitBranchCount(s *ast.EnumSplitStmt) int {
+	if s == nil {
+		return 0
+	}
+	count := len(s.Cases)
+	if len(s.ElseBody) > 0 {
+		count++
+	}
+	return count
+}
+
 func appendEnumBodies(s *ast.EnumSplitStmt) []ast.MicroflowStatement {
 	var stmts []ast.MicroflowStatement
 	for _, c := range s.Cases {

mdl/executor/cmd_microflows_builder_enum_split_test.go

@@ -3,6 +3,8 @@
 package executor
 
 import (
+	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/mendixlabs/mxcli/mdl/ast"
@@ -186,6 +188,22 @@ func TestEnumSplitAllCasesReturnWithoutElseDoesNotCreateFallthrough(t *testing.T
 	}
 }
 
+func TestEnumSplitBuilderRejectsMoreThanSupportedBranches(t *testing.T) {
+	fb := &flowBuilder{
+		spacing:  HorizontalSpacing,
+		measurer: &layoutMeasurer{},
+	}
+
+	if id := fb.addEnumSplit(enumSplitWithBranchCount(maxEnumSplitBranches + 1)); id != "" {
+		t.Fatalf("unsupported enum split returned split ID %q", id)
+	}
+
+	errors := strings.Join(fb.GetErrors(), "\n")
+	if !strings.Contains(errors, "enum split has 17 branches; at most 16 branches are supported") {
+		t.Fatalf("expected unsupported branch count error, got %q", errors)
+	}
+}
+
 func objectByID(objects []microflows.MicroflowObject, id model.ID) microflows.MicroflowObject {
 	for _, obj := range objects {
 		if obj.GetID() == id {
@@ -211,3 +229,79 @@ func logActivityHasMessage(obj microflows.MicroflowObject, message string) bool
 	}
 	return false
 }
+
+func enumSplitWithBranchCount(count int) *ast.EnumSplitStmt {
+	cases := make([]ast.EnumSplitCase, 0, count)
+	for i := 0; i < count; i++ {
+		cases = append(cases, ast.EnumSplitCase{
+			Value: fmt.Sprintf("Value%d", i+1),
+			Body: []ast.MicroflowStatement{
+				&ast.LogStmt{Level: ast.LogInfo, Message: &ast.LiteralExpr{Kind: ast.LiteralString, Value: "branch"}},
+			},
+		})
+	}
+	return &ast.EnumSplitStmt{
+		Variable: "SyntheticStatus",
+		Cases:    cases,
+	}
+}
+
+// TestEnumSplitBuilderPreservesFirstStatementAnchor guards against silent
+// loss of @anchor(from:..., to:...) on the first statement inside an enum
+// split case. Before the fix the enum split builder never read
+// stmtOwnAnchor(stmt) for case bodies, so any round-tripped anchor dropped
+// on re-exec — describe → exec → describe lost the FlowAnchor entirely.
+func TestEnumSplitBuilderPreservesFirstStatementAnchor(t *testing.T) {
+	fb := &flowBuilder{
+		spacing:  HorizontalSpacing,
+		measurer: &layoutMeasurer{},
+	}
+
+	// @anchor(to: bottom) on the first case statement — bottom is a
+	// non-default destination anchor (AnchorSideBottom == 2) so we can
+	// distinguish it from the layout default.
+	anchor := &ast.FlowAnchors{
+		From: ast.AnchorSideUnset,
+		To:   ast.AnchorSideBottom,
+	}
+	fb.addEnumSplit(&ast.EnumSplitStmt{
+		Variable: "Status",
+		Cases: []ast.EnumSplitCase{
+			{
+				Values: []string{"Open"},
+				Body: []ast.MicroflowStatement{
+					&ast.LogStmt{
+						Level:       ast.LogInfo,
+						Message:     &ast.LiteralExpr{Kind: ast.LiteralString, Value: "open"},
+						Annotations: &ast.ActivityAnnotations{Anchor: anchor},
+					},
+				},
+			},
+		},
+	})
+
+	var split *microflows.ExclusiveSplit
+	for _, obj := range fb.objects {
+		if s, ok := obj.(*microflows.ExclusiveSplit); ok {
+			split = s
+			break
+		}
+	}
+	if split == nil {
+		t.Fatal("expected ExclusiveSplit")
+	}
+
+	var firstCaseFlow *microflows.SequenceFlow
+	for _, f := range fb.flows {
+		if f.OriginID == split.ID {
+			firstCaseFlow = f
+		}
+	}
+	if firstCaseFlow == nil {
+		t.Fatal("expected split→case flow")
+	}
+	if firstCaseFlow.DestinationConnectionIndex != int(ast.AnchorSideBottom) {
+		t.Errorf("DestinationConnectionIndex = %d, want %d — @anchor(to: bottom) was dropped",
+			firstCaseFlow.DestinationConnectionIndex, int(ast.AnchorSideBottom))
+	}
+}

mdl/executor/cmd_microflows_builder_validate.go

@@ -101,6 +101,9 @@ func (fb *flowBuilder) validateStatement(stmt ast.MicroflowStatement) {
 		}
 
 	case *ast.EnumSplitStmt:
+		if count := enumSplitBranchCount(s); count > maxEnumSplitBranches {
+			fb.addError("enum split has %d branches; at most %d branches are supported", count, maxEnumSplitBranches)
+		}
 		for _, c := range s.Cases {
 			fb.validateStatements(c.Body)
 		}

mdl/executor/validate_microflow_enum_split_test.go

@@ -3,6 +3,7 @@
 package executor
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/mendixlabs/mxcli/mdl/ast"
@@ -115,3 +116,17 @@ func TestValidateMicroflow_EnumSplitBranchScopedVariable(t *testing.T) {
 	}
 	t.Fatalf("expected MDL005 for variable declared inside ENUM split branch, got %#v", violations)
 }
+
+func TestValidateMicroflowBody_EnumSplitRejectsMoreThanSupportedBranches(t *testing.T) {
+	stmt := &ast.CreateMicroflowStmt{
+		Name: ast.QualifiedName{Module: "Sample", Name: "Route"},
+		Body: []ast.MicroflowStatement{
+			enumSplitWithBranchCount(maxEnumSplitBranches + 1),
+		},
+	}
+
+	errors := strings.Join(ValidateMicroflowBody(stmt), "\n")
+	if !strings.Contains(errors, "enum split has 17 branches; at most 16 branches are supported") {
+		t.Fatalf("expected unsupported branch count error, got %q", errors)
+	}
+}

mdl/grammar/MDLParser.g4

@@ -1512,9 +1512,8 @@ callJavaScriptActionStatement
     ;
 
 // Legacy SOAP call. The preferred structured form stores service and mapping
-// references in STRING_LITERAL tokens rather than qualifiedName tokens because
-// Structured references prefer qualifiedName tokens. STRING_LITERAL remains as
-// a fallback for dangling raw IDs that cannot be represented as identifiers.
+// references as qualified names. STRING_LITERAL remains as a fallback for
+// dangling raw IDs that cannot be represented as identifiers.
 // Raw BSON remains the escape hatch for unsupported SOAP payload details.
 callWebServiceStatement
     : (VARIABLE EQUALS)? CALL WEB SERVICE