fix: Propagate updates to indictments in ifExists even if left side doesn't update, make PrecomputeUni tests aware of indictments

Author: Christopher-Chianelli

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractIfExistsNode.java

@@ -125,6 +125,11 @@ protected void incrementCounterRightUpdatingIndictment(ExistsCounter<LeftTuple_>
             } else {
                 doRetractCounter(counter);
             }
+        } else {
+            // count != 0, so only propagate if we are in an `ifExists`
+            if (shouldExist) {
+                doUpdateCounter(counter);
+            }
         } // Else do not even propagate an update
           // NOTE: By not propagating here, the left tuple's indicted objects can be stale
           //       if an element is removed.
@@ -152,6 +157,11 @@ protected void decrementCounterRightUpdatingIndictment(ExistsCounter<LeftTuple_>
             } else {
                 doInsertCounter(counter);
             }
+        } else {
+            // count != 0, so only propagate if we are in an `ifExists`
+            if (shouldExist) {
+                doUpdateCounter(counter);
+            }
         } // Else do not even propagate an update
     }
 
@@ -310,6 +320,15 @@ private void doRetractCounter(ExistsCounter<LeftTuple_> counter) {
         }
     }
 
+    private void doUpdateCounter(ExistsCounter<LeftTuple_> counter) {
+        switch (counter.state) {
+            case DYING, OK, UPDATING, CREATING -> propagationQueue.update(counter);
+            case DEAD, ABORTING -> propagationQueue.insert(counter);
+            default -> throw new IllegalStateException("Impossible state: the counter (%s) has an impossible insert state (%s)."
+                    .formatted(counter, counter.state));
+        }
+    }
+
     @Override
     protected boolean canProduceTuples() {
         // The left input must produce tuples no matter what,

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractIndexedIfExistsNode.java

@@ -100,6 +100,12 @@ private void updateCounterRight(LeftTuple_ leftTuple, Object compositeKey, Exist
         leftTuple.setStore(inputStoreIndexLeftCounterEntry, counterEntry);
         if (!isFiltering) {
             counter.countRight = rightSize(leftTuple, compositeKey);
+            if (leftTuple.getIndictmentSource() != IndictmentSource.DISABLED) {
+                IndictmentSource.clearSupport(getId(), leftTuple);
+                forEachRightFromLeft(leftTuple, compositeKey, rightTuple -> {
+                    IndictmentSource.addSupport(getId(), leftTuple, rightTuple);
+                });
+            }
         } else {
             // Trackers link themselves into the left tuple's inputStoreIndexLeftTrackerList slot.
             // No list object is needed; the slot starts null and the first tracker becomes the head.

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/tuple/indictment/IndictmentSource.java

@@ -86,6 +86,13 @@ static void addSupport(long nodeId, Tuple carry, Tuple support) {
         carry.getIndictmentSource().getSupportForNodeId(nodeId).add(support.getIndictmentSource());
     }
 
+    static void clearSupport(long nodeId, Tuple carry) {
+        if (carry.getIndictmentSource() == DISABLED) {
+            return;
+        }
+        carry.getIndictmentSource().getSupportForNodeId(nodeId).clear();
+    }
+
     static void removeSupport(long nodeId, Tuple carry, Tuple support) {
         if (carry.getIndictmentSource() == DISABLED) {
             return;
@@ -155,7 +162,7 @@ public void visitSources(Set<IndictmentSource> visited, long[] involvedNodeIds,
                 return;
             }
             for (var source : sourceList) {
-                source.visitSources(involvedNodeIds, sourceConsumer);
+                source.visitSources(visited, involvedNodeIds, sourceConsumer);
             }
         }
 

core/src/test/java/ai/timefold/solver/core/impl/score/stream/common/AbstractAdvancedGroupByConstraintStreamTest.java

@@ -547,17 +547,20 @@ void existsAfterGroupBy() {
         // From scratch
         scoreDirector.setWorkingSolution(solution);
         assertScore(scoreDirector,
-                assertMatchWithScore(-2, solution.getFirstEntityGroup(), 2L).withIndictedObjects(solution.getFirstEntity(),
-                        entity3),
-                assertMatchWithScore(-2, entityGroup1, 2L).withIndictedObjects(entity1, entity2));
+                assertMatchWithScore(-2, solution.getFirstEntityGroup(), 2L)
+                        .withIndictedObjects(solution.getFirstEntityGroup(), solution.getFirstEntity(),
+                                entity3),
+                assertMatchWithScore(-2, entityGroup1, 2L)
+                        .withIndictedObjects(entityGroup1, entity1, entity2));
 
         // Incremental
         scoreDirector.beforeProblemFactRemoved(entityGroup1);
         solution.getEntityGroupList().remove(entityGroup1);
         scoreDirector.afterProblemFactRemoved(entityGroup1);
         assertScore(scoreDirector,
-                assertMatchWithScore(-2, solution.getFirstEntityGroup(), 2L).withIndictedObjects(solution.getFirstEntity(),
-                        entity3));
+                assertMatchWithScore(-2, solution.getFirstEntityGroup(), 2L)
+                        .withIndictedObjects(solution.getFirstEntityGroup(), solution.getFirstEntity(),
+                                entity3));
     }
 
     @TestTemplate
@@ -621,16 +624,19 @@ void groupByAfterExistsBi() {
         // From scratch
         scoreDirector.setWorkingSolution(solution);
         assertScore(scoreDirector,
-                assertMatchWithScore(-3, solution.getFirstEntityGroup(), 3L).withIndictedObjects(solution.getFirstEntity(),
+                assertMatchWithScore(-3, solution.getFirstEntityGroup(), 3L).withIndictedObjects(
+                        solution.getFirstEntityGroup(), solution.getFirstEntity(),
                         entity1, entity2, entity3),
-                assertMatchWithScore(-3, entityGroup1, 3L).withIndictedObjects(entity1, entity2, entity3));
+                assertMatchWithScore(-3, entityGroup1, 3L).withIndictedObjects(
+                        entityGroup1, entity1, entity2, entity3));
 
         // Incremental
         scoreDirector.beforeProblemFactRemoved(entityGroup1);
         solution.getEntityGroupList().remove(entityGroup1);
         scoreDirector.afterProblemFactRemoved(entityGroup1);
         assertScore(scoreDirector,
-                assertMatchWithScore(-3, solution.getFirstEntityGroup(), 3L).withIndictedObjects(solution.getFirstEntity(),
+                assertMatchWithScore(-3, solution.getFirstEntityGroup(), 3L).withIndictedObjects(
+                        solution.getFirstEntityGroup(), solution.getFirstEntity(),
                         entity1, entity2, entity3));
     }
 

core/src/test/java/ai/timefold/solver/core/impl/score/stream/common/ConstraintStreamTestExtension.java

@@ -32,14 +32,6 @@ public boolean supportsTestTemplate(ExtensionContext context) {
 
     @Override
     public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContexts(ExtensionContext context) {
-        if (ConstraintStreamPrecomputeTest.class.isAssignableFrom(context.getTestClass().get())) {
-            // Precompute test use
-            return Stream
-                    .of(ConstraintMatchPolicy.ENABLED_WITHOUT_INDICTMENTS,
-                            ConstraintMatchPolicy.ENABLED_WITHOUT_JUSTIFICATIONS_AND_INDICTMENTS,
-                            ConstraintMatchPolicy.DISABLED)
-                    .map(ConstraintStreamTestExtension::invocationContext);
-        }
         return Stream
                 .of(ConstraintMatchPolicy.ENABLED,
                         ConstraintMatchPolicy.ENABLED_WITHOUT_INDICTMENTS,