chore: throw if pinned entity is inconsistent

Author: Christopher-Chianelli

core/src/main/java/ai/timefold/solver/core/impl/score/director/AbstractScoreDirector.java

@@ -353,6 +353,12 @@ public void unassignInconsistentEntities() {
                 if (listElementClass.isInstance(inconsistentEntity)) {
                     var inverse = Objects.requireNonNull(listVariableStateSupply.getInverseSingleton(inconsistentEntity));
                     int index = Objects.requireNonNull(listVariableStateSupply.getIndex(inconsistentEntity));
+
+                    if (listVariableDescriptor.isElementPinned(Objects.requireNonNull(workingSolution), inverse, index)) {
+                        throw new IllegalStateException(
+                                "Entity (%s) is pinned but is involved in a dependency loop".formatted(inconsistentEntity));
+                    }
+
                     beforeListVariableElementUnassigned(listVariableDescriptor, inconsistentEntity);
                     beforeListVariableChanged(listVariableDescriptor, inverse, index, index + 1);
                     listVariableDescriptor.removeElement(inverse, index);
@@ -375,6 +381,11 @@ private void unassignPlainEntity(Object inconsistentEntity) {
         if (entityDescriptor == null) {
             throw new IllegalStateException("Object (%s) is not an entity but is inconsistent".formatted(inconsistentEntity));
         }
+        if (entityDescriptor.isGenuine()
+                && !entityDescriptor.isMovable(Objects.requireNonNull(workingSolution), inconsistentEntity)) {
+            throw new IllegalStateException(
+                    "Entity (%s) is pinned but is involved in a dependency loop".formatted(inconsistentEntity));
+        }
         for (var genuineVariableDescriptor : entityDescriptor.getGenuineVariableDescriptorList()) {
             beforeVariableChanged(genuineVariableDescriptor, inconsistentEntity);
             genuineVariableDescriptor.setValue(inconsistentEntity, null);

core/src/main/java/ai/timefold/solver/core/impl/solver/recaller/BestSolutionRecaller.java

@@ -60,7 +60,8 @@ public void solvingStarted(SolverScope<Solution_> solverScope) {
             scoreDirector.unassignInconsistentEntities();
             innerScore = scoreDirector.calculateScore();
             if (innerScore.isInvalid()) {
-                throw new IllegalStateException("The initial solution passed to the solver is inconsistent even after unassigning involved entities.");
+                throw new IllegalStateException(
+                        "The initial solution passed to the solver is inconsistent even after unassigning involved entities.");
             }
         }
         var score = innerScore.raw();

core/src/test/java/ai/timefold/solver/core/impl/solver/DefaultSolverTest.java

@@ -1454,15 +1454,16 @@ void solveStaleDeclarativeShadows() {
     }
 
     @Test
-    void solveWhenIgnoringInconsistentSolutionsThrowsIfInitialSolutionInconsistent() {
+    void solveWhenIgnoringInconsistentSolutionsUnassignsIfInitialSolutionInconsistent() {
         // Solver config
         var solverConfig = PlannerTestUtils.buildSolverConfig(
                 TestdataDependencyNoInconsistentFieldSolution.class, TestdataDependencyNoInconsistentFieldEntity.class,
                 TestdataDependencyNoInconsistentFieldValue.class)
                 .withEasyScoreCalculatorClass(null)
                 .withConstraintProviderClass(TestdataDependencyNoInconsistentFieldConstraintProvider.class)
                 .withPhases(new CustomPhaseConfig()
-                        .withCustomPhaseCommands(command -> {}));
+                        .withCustomPhaseCommands(command -> {
+                        }));
 
         var e1 = new TestdataDependencyNoInconsistentFieldEntity("a");
         var e2 = new TestdataDependencyNoInconsistentFieldEntity("b");
@@ -1476,7 +1477,7 @@ void solveWhenIgnoringInconsistentSolutionsThrowsIfInitialSolutionInconsistent()
         b2.setDependencies(List.of(b1));
 
         e1.setValues(List.of(b2, b1));
-        e2.setValues(List.of(a2, a1));
+        e2.setValues(List.of(a1, a2));
 
         var entities = List.of(e1, e2);
         var values = List.of(a1, a2, b1, b2);
@@ -1487,19 +1488,21 @@ void solveWhenIgnoringInconsistentSolutionsThrowsIfInitialSolutionInconsistent()
         problem.setValues(values);
 
         var solution = PlannerTestUtils.solve(solverConfig, problem, false);
-        assertThat(solution.getEntities().getFirst().getValues().isEmpty());
-        assertThat(solution.getEntities().getLast().getValues().isEmpty());
+        assertThat(solution.getEntities().getFirst().getValues()).isEmpty();
+        assertThat(solution.getEntities().getLast().getValues()).hasSize(2);
+
+        var sE2 = solution.getEntities().getLast();
 
         var sA1 = solution.getValues().get(0);
         var sA2 = solution.getValues().get(1);
         var sB1 = solution.getValues().get(2);
         var sB2 = solution.getValues().get(3);
 
-        assertThat(sA1.getEntity()).isNull();
+        assertThat(sA1.getEntity()).isEqualTo(sE2);
         assertThat(sA1.getPreviousValue()).isNull();
 
-        assertThat(sA2.getEntity()).isNull();
-        assertThat(sA2.getPreviousValue()).isNull();
+        assertThat(sA2.getEntity()).isEqualTo(sE2);
+        assertThat(sA2.getPreviousValue()).isEqualTo(sA1);
 
         assertThat(sB1.getEntity()).isNull();
         assertThat(sB1.getPreviousValue()).isNull();
@@ -1508,6 +1511,44 @@ void solveWhenIgnoringInconsistentSolutionsThrowsIfInitialSolutionInconsistent()
         assertThat(sB2.getPreviousValue()).isNull();
     }
 
+    @Test
+    void solveWhenIgnoringInconsistentSolutionsThrowsIfInconsistentEntityPinned() {
+        // Solver config
+        var solverConfig = PlannerTestUtils.buildSolverConfig(
+                TestdataDependencyNoInconsistentFieldSolution.class, TestdataDependencyNoInconsistentFieldEntity.class,
+                TestdataDependencyNoInconsistentFieldValue.class)
+                .withEasyScoreCalculatorClass(null)
+                .withConstraintProviderClass(TestdataDependencyNoInconsistentFieldConstraintProvider.class);
+
+        var e1 = new TestdataDependencyNoInconsistentFieldEntity("a");
+        var e2 = new TestdataDependencyNoInconsistentFieldEntity("b");
+
+        var a1 = new TestdataDependencyNoInconsistentFieldValue("a1");
+        var a2 = new TestdataDependencyNoInconsistentFieldValue("a2");
+        var b1 = new TestdataDependencyNoInconsistentFieldValue("b1");
+        var b2 = new TestdataDependencyNoInconsistentFieldValue("b2");
+
+        a2.setDependencies(List.of(a1));
+        b2.setDependencies(List.of(b1));
+
+        e1.setValues(List.of(b2, b1));
+        e2.setValues(List.of(a2, a1));
+
+        var entities = List.of(e1, e2);
+        var values = List.of(a1, a2, b1, b2);
+
+        e1.setPinnedToIndex(1);
+
+        var problem = new TestdataDependencyNoInconsistentFieldSolution();
+
+        problem.setEntities(entities);
+        problem.setValues(values);
+
+        assertThatCode(() -> PlannerTestUtils.solve(solverConfig, problem, false))
+                .isInstanceOf(IllegalStateException.class)
+                .hasMessageContainingAll("Entity", "b2", "is pinned but is involved in a dependency loop");
+    }
+
     @Test
     void solveIgnoreInconsistent() {
         // Solver config

core/src/test/java/ai/timefold/solver/core/testdomain/shadow/no_inconsistent_field/TestdataDependencyNoInconsistentFieldEntity.java

@@ -7,6 +7,7 @@
 
 import ai.timefold.solver.core.api.domain.common.PlanningId;
 import ai.timefold.solver.core.api.domain.entity.PlanningEntity;
+import ai.timefold.solver.core.api.domain.entity.PlanningPinToIndex;
 import ai.timefold.solver.core.api.domain.variable.PlanningListVariable;
 
 @PlanningEntity
@@ -17,6 +18,9 @@ public class TestdataDependencyNoInconsistentFieldEntity {
     @PlanningListVariable
     List<TestdataDependencyNoInconsistentFieldValue> values;
 
+    @PlanningPinToIndex
+    int pinnedToIndex;
+
     LocalDateTime startTime;
 
     public TestdataDependencyNoInconsistentFieldEntity() {
@@ -57,6 +61,14 @@ public void setStartTime(LocalDateTime startTime) {
         this.startTime = startTime;
     }
 
+    public int getPinnedToIndex() {
+        return pinnedToIndex;
+    }
+
+    public void setPinnedToIndex(int pinnedToIndex) {
+        this.pinnedToIndex = pinnedToIndex;
+    }
+
     @Override
     public String toString() {
         return "TestdataPredecessorEntity{id=%s, values=%s, startTime=%s}".formatted(id, values, startTime);