Merge pull request #1691 from ako/fix/1557-microflow-splice-refusals

fix: microflow splice refusals — find/filter where respelling (#856), alter-block variables (#1399)

Author: ako

.claude/skills/fix-issue/findings/mdl-executor/2026-10-25-alter-block-variables-judged-against-stored-flow.json

@@ -0,0 +1 @@
+{"area": "mdl/executor", "date": "2026-10-25", "symptom": "(1) `alter microflow` with `insert after $X begin declare $Late Integer = 0; end;` and then `replace loop … with begin loop … set $Late = $Late + 1; … end;` passed check with a 'not predicted' note and failed at exec: 'the fragment has errors: variable 'Late' is not declared'. (2) A producer moved upstream — `create or modify` restating `$Code = call …` above the declare it followed, or the same as an alter insert+drop in either order — was refused 'the fragment declares $Code, which the microflow already has' (and, once past that, '$Code is still used by: log …; return $Code')", "cause": "Two variable verdicts of an alter block (and of the patch create or modify splices with, which is one) were still taken against the flow as stored: the fragment builder was seeded only with the stored flow's variables (storedVariables + the full build's entity types), so a later fragment could read but not `set` or member-access what an earlier operation declares; and checkFragmentScope refused a fragment declaring any variable a stored activity declares, at the moment it ran, before a later operation dropped that activity — while checkOutputUnused counted readers the inserted producer now feeds", "file": "mdl/executor/cmd_alter_flow.go (applyTo, fragmentBuilder, buildFragmentVars, noteFragment, checkOutputUnused, checkDeclaredUnclashed); mdl/executor/validate_flow_verdicts.go (alterFlowViolations)", "fix": "Each applied fragment's declared variables (with the types its builder resolved) seed later fragments' builders, in check's pre-build as in exec; the clash with a stored producer is judged once every operation is applied and skips one the block takes away (or whose loop it replaces); a stored or fragment reader of a removed output is no 'user' when another operation's fragment declares the variable upstream of it (declaredOnPath)", "insight": "2f42df658 moved checkOutputUnused to the end of the block but left its two siblings per-operation; any check that answers 'does this variable exist' has to be judged against the flow the block writes, or create or modify's own diff (which turns a reorder into insert+drop) trips it. A useful corollary: a create-or-modify body that builds declares each variable once, so a 'declares $X, which the microflow already has' refusal from the splice is always false — the 1361 test pinned one as expected and now asserts the splice. Known order rule kept: a declaration by a LATER operation is not known to an earlier fragment (check reports it unpredicted, exec refuses it)", "refs": ["ako/mxcli#1399", "mendixlabs/mxcli#1517", "mendixlabs/mxcli#1361"], "test": "TestAlterMicroflow_FragmentBuiltWithAnEarlierOperationsDeclaration, TestCreateOrModify_ProducerMovedEarlierKeepsItsReaders, TestAlterMicroflow_ProducerMovedEarlier (mdl/executor/cmd_alter_flow_block_vars_1399_pedapp_test.go); TestCheckFlowVerdicts_Issue1361_VariableClash"}

.claude/skills/fix-issue/findings/mdl-executor/2026-10-25-find-filter-where-bare-member-never-matches.json

@@ -0,0 +1 @@
+{"area": "mdl/executor", "date": "2026-10-25", "symptom": "`create or modify microflow` of a flow holding `$A = find $L where Code = 'x'` (or `filter … where` with a bare member) and one real change next to it was refused under mdl 1 — 'replace $N: the fragment declares $A, which the microflow already has' — and rebuilt whole (MDL-V1-REBUILD) under mdl 0; away from the change the find was needlessly replaced on every run. An unchanged re-run was still 'Unchanged'", "cause": "The builder stores a bare member of a find/filter-by-expression predicate as `$currentObject/<member>` (qualifyIteratorAttributes, #1002) and describe prints the stored form, so the statement as the script spells it never matched its own stored activity in the statement diff; the unchanged re-run escaped only because builtAsStored compares built graphs before the statement diff runs", "file": "mdl/executor/flow_member_spelling.go (memberSpeller.respell, qualifiedPredicate)", "fix": "describedMemberSpellings rewrites a find/filter-by-expression predicate with the builder's own qualifyIteratorAttributes before the statement diff, keeping the predicate as written when the builder would refuse it", "insight": "A spelling the builder normalises is invisible to the identity check (an unchanged re-run passes) and only shows when a REAL change elsewhere sends the flow to the statement diff, so the probe that finds these is: create each flow, re-run it with one inserted statement, and flag any summary other than '1 inserted'. Over 02-microflow-examples (118 flows) and 23 hand-picked respellings this was the only clause left; sort without asc, member qualification, association spelling in expressions, `<>`, aggregates (stored as written) all matched", "refs": ["ako/mxcli#856", "#1002", "#839"], "test": "TestCreateOrModify_ListOperationWhereBareMemberIsItsStoredActivity, TestCreateOrModify_ListOperationWhereChangedPredicateIsAChange (mdl/executor/flow_splice_list_op_where_856_pedapp_test.go)"}

.claude/skills/mendix/write-microflows/reference/pitfalls.md

@@ -362,10 +362,16 @@ the scope checks judge the flow the **whole block** writes:
 
 - a fragment may read a variable an earlier operation of the block declares, when that
   declaration lands upstream of it (an `insert after`/`replace` of a node before it, or
-  an `insert before` the node it replaces or inserts after);
+  an `insert before` the node it replaces or inserts after) — and may `set` it or name
+  its members, since the fragment is built knowing what the earlier operations declare
+  (ako/mxcli#1399). Declare first, use after: a declaration made by a *later*
+  operation of the block is not known to an earlier one's fragment;
 - an activity whose output is taken away is still "used" only by readers the block
-  leaves in place — so a rename (the producer, every reader and the `return`) goes in
-  **one** block:
+  leaves in place, and not by a reader that another operation's fragment declares the
+  variable for upstream of it — so a producer can be moved up the flow (insert it
+  where it goes, drop it where it was; `create or modify` does this for a reordered
+  body), and a rename (the producer, every reader and the `return`) goes in **one**
+  block:
 
 ```mdl
 mdl 1;

mdl-examples/bug-tests/splice-1399-alter-block-variables.mdl

@@ -0,0 +1,82 @@
+-- ============================================================================
+-- ako/mxcli#1399 (mendixlabs/mxcli#1517) — variables of one alter block,
+-- and a producer moved upstream of where it was
+-- ============================================================================
+--
+-- The operations of one `alter microflow` block — and the patch a
+-- `create or modify` splices with, which is one — write ONE flow, but two of
+-- their variable verdicts were still taken against the flow as stored:
+--
+--   Repro B  a fragment was built knowing only the stored flow's variables,
+--            so `set $Late = …` in a replaced loop failed at exec with
+--            "variable 'Late' is not declared" although the insert before it
+--            in the same block declares $Late upstream — while check passed
+--            with a "not predicted" note.
+--
+--   Used return  a producer moved earlier (`$Code = call …` above the
+--            declare it followed) was refused "the fragment declares $Code,
+--            which the microflow already has" by the stored $Code the same
+--            patch drops, and in the other order "$Code is still used by:
+--            log …; return $Code" by readers the moved producer now feeds.
+--
+-- To reproduce: exec this file against any project. Expected:
+--   Altered microflow BugTest1399.LoopFlow
+--   Modified microflow: BugTest1399.MoveFlow (spliced: 1 inserted, 1 dropped)
+-- Before the fix exec stopped at the alter ("the fragment has errors: variable
+-- 'Late' is not declared") and rolled the whole script back; without the
+-- alter it stopped at the second MoveFlow statement. mx check: 0 errors.
+-- The file can be run again: LoopFlow is dropped and made afresh, and
+-- MoveFlow moves its producer back and forth.
+
+mdl 1;
+
+create module BugTest1399;
+
+create or modify persistent entity BugTest1399.Item (
+  Name: String(100)
+);
+
+create or modify microflow BugTest1399.Helper () returns String
+begin
+  return 'x';
+end;
+
+-- Repro B: the replaced loop sets the variable the insert declares.
+drop microflow if exists BugTest1399.LoopFlow;
+
+create microflow BugTest1399.LoopFlow ($Items: List of BugTest1399.Item)
+begin
+  declare $X Integer = 0;
+  loop $It in $Items
+  begin
+    log info node 'BugTest1399' $It/Name;
+  end loop;
+  log info node 'BugTest1399' 'done';
+end;
+
+alter microflow BugTest1399.LoopFlow {
+  insert after declare $X Integer = 0 begin declare $Late Integer = 0; end;
+  replace loop $It in $Items with begin
+    loop $It in $Items
+    begin
+      set $Late = $Late + 1;
+    end loop;
+  end;
+};
+
+-- Used return: the producer of the returned $Code moves above the declare.
+create or modify microflow BugTest1399.MoveFlow () returns String
+begin
+  declare $N Integer = 1;
+  $Code = call microflow BugTest1399.Helper();
+  log info node 'BugTest1399' $Code;
+  return $Code;
+end;
+
+create or modify microflow BugTest1399.MoveFlow () returns String
+begin
+  $Code = call microflow BugTest1399.Helper();
+  declare $N Integer = 1;
+  log info node 'BugTest1399' $Code;
+  return $Code;
+end;

mdl-examples/bug-tests/splice-856-list-operation-where-bare-member.mdl

@@ -0,0 +1,58 @@
+-- ============================================================================
+-- ako/mxcli#856 — a find/filter `where` naming a member bare never matched
+-- its own stored activity, so a one-line change next to it was refused
+-- ============================================================================
+--
+-- `find $L where Code = 'x'` is stored as `$currentObject/Code = 'x'` (Mendix
+-- evaluates the predicate once per item, and a bare name is CE0117), and
+-- describe prints the stored form. create or modify matches the statements it
+-- is given against that description, so the statement as written read as
+-- changed on every run:
+--
+--   - a re-run that changed nothing was still Unchanged (the built flow is
+--     the stored one);
+--   - a re-run with a real change elsewhere replaced the find too, and next
+--     to the change the two became one replace whose fragment declares $A
+--     while the stored find still does. Under `mdl 1;`:
+--
+--       this change cannot be spliced into the stored flow: alter microflow
+--       BugTest856.F: replace $N: the fragment declares $A, which the
+--       microflow already has; choose another name. Nothing was written
+--
+--     and under mdl 0 the whole flow was rebuilt (MDL-V1-REBUILD warning).
+--
+-- The predicate is now compared as the builder stores it.
+--
+-- To reproduce: exec this file against a project. Expected:
+--   Created microflow: BugTest856.F
+--   Modified microflow: BugTest856.F (spliced: 1 replaced)
+-- Before the fix the second statement was refused and exec rolled the whole
+-- script back. Running the file again sets the declare back and forth, and
+-- each statement again replaces the declare alone (spliced: 1 replaced).
+
+mdl 1;
+
+create module BugTest856;
+
+create or modify persistent entity BugTest856.Row (
+  Code: String(100),
+  Qty: Integer
+);
+
+create or modify microflow BugTest856.F ($L: List of BugTest856.Row)
+begin
+  declare $N Integer = 0;
+  $A = find $L where Code = 'x';
+  $B = filter $L where Code != 'y' and Qty > 0;
+  log info node 'BugTest856' toString($N);
+end;
+
+-- The same flow with one change, next to the find: only the declare is
+-- replaced; the find and the filter keep their $IDs.
+create or modify microflow BugTest856.F ($L: List of BugTest856.Row)
+begin
+  declare $N Integer = 1;
+  $A = find $L where Code = 'x';
+  $B = filter $L where Code != 'y' and Qty > 0;
+  log info node 'BugTest856' toString($N);
+end;