Merge branch 'main' into pr4-nanoflows-all

Author: ako

mdl-examples/bug-tests/350-manual-while-true-loop-roundtrip.mdl

@@ -0,0 +1,62 @@
+-- ============================================================================
+-- Bug #350: Manual `while true` retry-loop roundtrip
+-- ============================================================================
+--
+-- Symptom (before fix):
+--   Studio Pro projects with manual retry loops authored as
+--     while true
+--     begin
+--       <work>
+--       if <done> then return ...; end if;
+--       continue;
+--     end while;
+--   could be described correctly, but `mxcli exec` rebuilt the same MDL
+--   into either a `LoopedActivity` (collection-style loop) or a flow
+--   with a synthetic fallthrough `EndEvent`. The resulting MPR diverged
+--   from the original — a back-edge merge expected by Studio Pro was
+--   missing — and `mx check` could fail or the model's runtime semantics
+--   could change silently.
+--
+-- Root cause:
+--   The builder accepted `while`, `break`, `continue` syntax but never
+--   materialized BreakEvent/ContinueEvent objects. `continue` in a
+--   manual `while true` body was treated as plain fallthrough.
+--
+-- After fix:
+--   - `BreakEvent` and `ContinueEvent` objects are produced for break/continue.
+--   - Both are treated as terminal branch statements for control-flow analysis.
+--   - Manual `while true` bodies that need a graph-level back-edge are
+--     built as an `ExclusiveMerge` loop header.
+--   - `continue` inside that manual loop routes back to the merge instead
+--     of producing a standalone `ContinueEvent`.
+--
+-- Usage:
+--   mxcli exec mdl-examples/bug-tests/350-manual-while-true-loop-roundtrip.mdl -p app.mpr
+--   mxcli -p app.mpr -c "describe microflow BugTest350.MF_ManualRetryLoop"
+--   `mx check` against the resulting MPR must report 0 errors.
+-- ============================================================================
+
+create module BugTest350;
+
+create entity BugTest350.Item (
+  IsDone : boolean
+);
+/
+
+-- Manual while-true retry loop. The graph rebuild must use an
+-- ExclusiveMerge back-edge — not a LoopedActivity and not a fallthrough
+-- EndEvent — and the `continue` must route to that merge.
+create microflow BugTest350.MF_ManualRetryLoop (
+  $Item: BugTest350.Item
+)
+returns boolean as $Done
+begin
+  while true
+  begin
+    if $Item/IsDone then
+      return true;
+    end if;
+    continue;
+  end while;
+end;
+/

mdl/executor/cmd_microflows_builder.go

@@ -37,11 +37,13 @@ type flowBuilder struct {
 	// continues) so the continuing branch's @anchor survives to the actual
 	// splitID→nextActivity flow — which is emitted one iteration later by the
 	// outer loop, not by addIfStatement.
-	nextFlowAnchor     *ast.FlowAnchors
-	backend            backend.FullBackend          // For looking up page/microflow references
-	hierarchy          *ContainerHierarchy          // For resolving container IDs to module names
-	pendingAnnotations *ast.ActivityAnnotations     // Pending annotations to attach to next activity
-	restServices       []*model.ConsumedRestService // Cached REST services for parameter classification
+	nextFlowAnchor       *ast.FlowAnchors
+	backend              backend.FullBackend          // For looking up page/microflow references
+	hierarchy            *ContainerHierarchy          // For resolving container IDs to module names
+	pendingAnnotations   *ast.ActivityAnnotations     // Pending annotations to attach to next activity
+	restServices         []*model.ConsumedRestService // Cached REST services for parameter classification
+	listInputVariables   map[string]bool              // Variables later consumed by list-only actions
+	objectInputVariables map[string]bool              // Variables later consumed through object/attribute access
 	// previousStmtAnchor holds the Anchor annotation of the statement that
 	// just emitted an activity, so the next flow's OriginConnectionIndex can
 	// be overridden by the user. Cleared after each flow is created.
@@ -51,6 +53,8 @@ type flowBuilder struct {
 	microflowsCacheLoaded bool
 	nanoflowsCache        []*microflows.Nanoflow
 	nanoflowsCacheLoaded  bool
+	previousStmtAnchor   *ast.FlowAnchors
+	manualLoopBackTarget model.ID
 }
 
 // addError records a validation error during flow building.

mdl/executor/cmd_microflows_builder_actions.go

@@ -304,10 +304,19 @@ func (fb *flowBuilder) addRetrieveAction(s *ast.RetrieveStmt) model.ID {
 			startVarType = fb.varTypes[s.StartVariable]
 		}
 
-		if assocInfo != nil && assocInfo.Type == domainmodel.AssociationTypeReference &&
+		outputUsedAsList := fb.listInputVariables != nil && fb.listInputVariables[s.Variable]
+		outputUsedAsObject := fb.objectInputVariables != nil && fb.objectInputVariables[s.Variable]
+		// Owner-both Reference associations need later usage context: the same
+		// compact retrieve can be consumed as either a list or a single object.
+		expandReverseReference := assocInfo != nil &&
+			assocInfo.Type == domainmodel.AssociationTypeReference &&
 			assocInfo.Owner != "" &&
 			assocInfo.parentPersistable &&
-			assocInfo.childEntityQN != "" && startVarType == assocInfo.childEntityQN {
+			assocInfo.childEntityQN != "" &&
+			startVarType == assocInfo.childEntityQN &&
+			(assocInfo.Owner != domainmodel.AssociationOwnerBoth || outputUsedAsList && !outputUsedAsObject)
+
+		if expandReverseReference {
 			// Reverse traversal on Reference: child → parent (one-to-many)
 			// Use DatabaseRetrieveSource with XPath to get a list of parent entities
 			dbSource := &microflows.DatabaseRetrieveSource{
@@ -335,7 +344,7 @@ func (fb *flowBuilder) addRetrieveAction(s *ast.RetrieveStmt) model.ID {
 					if startVarType == assocInfo.childEntityQN {
 						otherEntity = assocInfo.parentEntityQN
 					}
-					if startVarType == assocInfo.childEntityQN {
+					if startVarType == assocInfo.childEntityQN && !outputUsedAsObject {
 						fb.varTypes[s.Variable] = "List of " + otherEntity
 					} else {
 						fb.varTypes[s.Variable] = otherEntity

mdl/executor/cmd_microflows_builder_control.go

@@ -436,9 +436,150 @@ func (fb *flowBuilder) addLoopStatement(s *ast.LoopStmt) model.ID {
 	return loop.ID
 }
 
+func isManualWhileTrueCandidate(s *ast.WhileStmt) bool {
+	if s == nil || containsBreakForCurrentLoop(s.Body) || (!containsContinueStmt(s.Body) && !containsTerminalStmt(s.Body)) {
+		return false
+	}
+	lit, ok := s.Condition.(*ast.LiteralExpr)
+	if !ok || lit.Kind != ast.LiteralBoolean {
+		return false
+	}
+	value, ok := lit.Value.(bool)
+	return ok && value
+}
+
+func containsBreakForCurrentLoop(stmts []ast.MicroflowStatement) bool {
+	for _, stmt := range stmts {
+		switch s := stmt.(type) {
+		case *ast.BreakStmt:
+			return true
+		case *ast.IfStmt:
+			if containsBreakForCurrentLoop(s.ThenBody) || containsBreakForCurrentLoop(s.ElseBody) {
+				return true
+			}
+		case *ast.LoopStmt, *ast.WhileStmt:
+			// A break inside a nested loop exits that nested loop, not this
+			// manual while-true back-edge.
+			continue
+		}
+	}
+	return false
+}
+
+func containsContinueStmt(stmts []ast.MicroflowStatement) bool {
+	for _, stmt := range stmts {
+		switch s := stmt.(type) {
+		case *ast.ContinueStmt:
+			return true
+		case *ast.IfStmt:
+			if containsContinueStmt(s.ThenBody) || containsContinueStmt(s.ElseBody) {
+				return true
+			}
+		case *ast.LoopStmt:
+			if containsContinueStmt(s.Body) {
+				return true
+			}
+		case *ast.WhileStmt:
+			if containsContinueStmt(s.Body) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (fb *flowBuilder) addManualWhileTrueStatement(s *ast.WhileStmt) model.ID {
+	mergeX := fb.posX
+	mergeY := fb.posY
+	if s.Annotations != nil && s.Annotations.Position != nil {
+		mergeX = s.Annotations.Position.X
+		mergeY = s.Annotations.Position.Y
+	}
+
+	merge := &microflows.ExclusiveMerge{
+		BaseMicroflowObject: microflows.BaseMicroflowObject{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Position:    model.Point{X: mergeX, Y: mergeY},
+			Size:        model.Size{Width: MergeSize, Height: MergeSize},
+		},
+	}
+	fb.objects = append(fb.objects, merge)
+	if fb.pendingAnnotations != nil {
+		fb.applyAnnotations(merge.ID, fb.pendingAnnotations)
+		fb.pendingAnnotations = nil
+	}
+
+	savedBackTarget := fb.manualLoopBackTarget
+	fb.manualLoopBackTarget = merge.ID
+	defer func() { fb.manualLoopBackTarget = savedBackTarget }()
+
+	fb.posX = mergeX + MergeSize + HorizontalSpacing/2
+	fb.posY = mergeY
+
+	lastBodyID := merge.ID
+	var pendingBodyCase string
+	var pendingBodyAnchor *ast.FlowAnchors
+	var prevBodyAnchor *ast.FlowAnchors
+	for _, stmt := range s.Body {
+		thisAnchor := stmtOwnAnchor(stmt)
+		actID := fb.addStatement(stmt)
+		if actID == "" {
+			continue
+		}
+		if fb.pendingAnnotations != nil {
+			fb.applyAnnotations(actID, fb.pendingAnnotations)
+			fb.pendingAnnotations = nil
+		}
+		if lastBodyID != "" && lastBodyID != actID {
+			var flow *microflows.SequenceFlow
+			if pendingBodyCase != "" {
+				flow = newHorizontalFlowWithCase(lastBodyID, actID, pendingBodyCase)
+				if pendingBodyAnchor != nil {
+					prevBodyAnchor = pendingBodyAnchor
+				}
+				pendingBodyCase = ""
+				pendingBodyAnchor = nil
+			} else {
+				flow = newHorizontalFlow(lastBodyID, actID)
+			}
+			applyUserAnchors(flow, prevBodyAnchor, thisAnchor)
+			fb.flows = append(fb.flows, flow)
+		}
+		prevBodyAnchor = thisAnchor
+		if fb.nextConnectionPoint != "" {
+			lastBodyID = fb.nextConnectionPoint
+			fb.nextConnectionPoint = ""
+			pendingBodyCase = fb.nextFlowCase
+			fb.nextFlowCase = ""
+			pendingBodyAnchor = fb.nextFlowAnchor
+			fb.nextFlowAnchor = nil
+		} else {
+			lastBodyID = actID
+		}
+	}
+
+	if lastBodyID != "" && lastBodyID != merge.ID && !lastStmtIsReturn(s.Body) {
+		var flow *microflows.SequenceFlow
+		if pendingBodyCase != "" {
+			flow = newHorizontalFlowWithCase(lastBodyID, merge.ID, pendingBodyCase)
+		} else {
+			flow = newHorizontalFlow(lastBodyID, merge.ID)
+		}
+		applyUserAnchors(flow, pendingBodyAnchor, pendingBodyAnchor)
+		fb.flows = append(fb.flows, flow)
+	}
+	fb.endsWithReturn = true
+
+	return merge.ID
+}
+
 // addWhileStatement creates a WHILE loop using LoopedActivity with WhileLoopCondition.
 // Layout matches addLoopStatement but without iterator icon space.
 func (fb *flowBuilder) addWhileStatement(s *ast.WhileStmt) model.ID {
+	if isManualWhileTrueCandidate(s) {
+		return fb.addManualWhileTrueStatement(s)
+	}
+
 	// Snapshot & clear this WHILE's own annotations so the body's recursive
 	// addStatement calls can't consume them (see addLoopStatement).
 	savedWhileAnnotations := fb.pendingAnnotations
@@ -523,3 +664,33 @@ func (fb *flowBuilder) addWhileStatement(s *ast.WhileStmt) model.ID {
 
 	return loop.ID
 }
+
+func (fb *flowBuilder) addBreakEvent() model.ID {
+	event := &microflows.BreakEvent{
+		BaseMicroflowObject: microflows.BaseMicroflowObject{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Position:    model.Point{X: fb.posX, Y: fb.posY},
+			Size:        model.Size{Width: EventSize, Height: EventSize},
+		},
+	}
+	fb.objects = append(fb.objects, event)
+	fb.posX += fb.spacing
+	return event.ID
+}
+
+func (fb *flowBuilder) addContinueEvent() model.ID {
+	if fb.manualLoopBackTarget != "" {
+		return fb.manualLoopBackTarget
+	}
+
+	event := &microflows.ContinueEvent{
+		BaseMicroflowObject: microflows.BaseMicroflowObject{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Position:    model.Point{X: fb.posX, Y: fb.posY},
+			Size:        model.Size{Width: EventSize, Height: EventSize},
+		},
+	}
+	fb.objects = append(fb.objects, event)
+	fb.posX += fb.spacing
+	return event.ID
+}

mdl/executor/cmd_microflows_builder_flows.go

@@ -206,12 +206,13 @@ func pendingFlowAnchors(previousAnchor, pendingAnchor, stmtAnchor *ast.FlowAncho
 }
 
 // lastStmtIsReturn reports whether execution of a body is guaranteed to terminate
-// (via RETURN or RAISE ERROR) on every path — i.e. control can never fall off the
-// end of the body into the parent flow.
+// (via RETURN, RAISE ERROR, BREAK, or CONTINUE) on every path — i.e. control can
+// never fall off the end of the body into the parent flow.
 //
-// Terminal statements: ReturnStmt, RaiseErrorStmt. An IfStmt is terminal iff it
-// has an ELSE and both branches are terminal (recursively). A LoopStmt is never
-// terminal — BREAK can exit the loop even if the body returns.
+// Terminal statements: ReturnStmt, RaiseErrorStmt, BreakStmt, ContinueStmt. An
+// IfStmt is terminal iff it has an ELSE and both branches are terminal
+// (recursively). A LoopStmt is never terminal — BREAK can exit the loop even if
+// the body returns.
 //
 // Naming kept for history; the predicate is really "last stmt is a guaranteed
 // terminator". Missing this case causes the outer IF to emit a dangling
@@ -230,12 +231,40 @@ func isTerminalStmt(stmt ast.MicroflowStatement) bool {
 		return true
 	case *ast.RaiseErrorStmt:
 		return true
+	case *ast.BreakStmt:
+		return true
+	case *ast.ContinueStmt:
+		return true
 	case *ast.IfStmt:
 		if len(s.ElseBody) == 0 {
 			return false
 		}
 		return lastStmtIsReturn(s.ThenBody) && lastStmtIsReturn(s.ElseBody)
+	case *ast.WhileStmt:
+		return isManualWhileTrueCandidate(s)
 	default:
 		return false
 	}
 }
+
+func containsTerminalStmt(stmts []ast.MicroflowStatement) bool {
+	for _, stmt := range stmts {
+		switch s := stmt.(type) {
+		case *ast.ReturnStmt, *ast.RaiseErrorStmt:
+			return true
+		case *ast.IfStmt:
+			if containsTerminalStmt(s.ThenBody) || containsTerminalStmt(s.ElseBody) {
+				return true
+			}
+		case *ast.LoopStmt:
+			if containsTerminalStmt(s.Body) {
+				return true
+			}
+		case *ast.WhileStmt:
+			if containsTerminalStmt(s.Body) {
+				return true
+			}
+		}
+	}
+	return false
+}