chore: review comments

Author: Christopher-Chianelli

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

@@ -95,7 +95,7 @@ public abstract class AbstractScoreDirector<Solution_, Score_ extends Score<Scor
     private long calculationCount = 0L;
     protected @Nullable Solution_ workingSolution;
     private int workingInitScore = 0;
-    private boolean lastVariableUpdateWasSuccessful = true;
+    private boolean lastVariableUpdateSuccessful = true;
 
     private final boolean isStepAssertOrMore;
 
@@ -246,7 +246,7 @@ public NeighborhoodNotifier<Solution_> getNeighborhoodNotifier() {
 
     @Override
     public final InnerScore<Score_> calculateScore() {
-        if (lastVariableUpdateWasSuccessful) {
+        if (lastVariableUpdateSuccessful) {
             return innerCalculateScore();
         } else {
             var invalidScore = InnerScore.invalid(getScoreDefinition().getZeroScore());
@@ -343,12 +343,12 @@ protected void afterSetWorkingSolution() {
         // Do nothing
     }
 
-    public List<Object> getInconsistentEntities() {
+    public List<Object> computeInconsistentEntities() {
         return shadowVariableSupport.getInconsistentEntities();
     }
 
     public void unassignInconsistentEntities() {
-        var inconsistentEntities = getInconsistentEntities();
+        var inconsistentEntities = computeInconsistentEntities();
         if (listVariableStateSupply != null) {
             var listVariableDescriptor = listVariableStateSupply.getSourceVariableDescriptor();
             var listElementClass = listVariableStateSupply.getSourceVariableDescriptor().getElementType();
@@ -490,11 +490,11 @@ public Solution_ cloneSolution(Solution_ originalSolution) {
 
     @Override
     public void updateShadowVariables() {
-        lastVariableUpdateWasSuccessful = shadowVariableSupport.updateShadowVariables();
+        lastVariableUpdateSuccessful = shadowVariableSupport.updateShadowVariables();
     }
 
-    public boolean isLastVariableUpdateWasSuccessful() {
-        return lastVariableUpdateWasSuccessful;
+    public boolean isLastVariableUpdateSuccessful() {
+        return lastVariableUpdateSuccessful;
     }
 
     /**
@@ -509,7 +509,7 @@ protected void clearPendingShadowVariableUpdates() {
 
     @Override
     public void forceUpdateShadowVariables() {
-        lastVariableUpdateWasSuccessful = shadowVariableSupport.forceUpdateAllShadowVariables(getWorkingSolution());
+        lastVariableUpdateSuccessful = shadowVariableSupport.forceUpdateAllShadowVariables(getWorkingSolution());
     }
 
     protected void setCalculatedScore(Score_ score) {

core/src/main/java/ai/timefold/solver/core/impl/solver/DefaultSolutionManager.java

@@ -53,7 +53,7 @@ public ScoreDirectorFactory<Solution_, Score_> getScoreDirectorFactory() {
     public Score_ update(Solution_ solution, SolutionUpdatePolicy solutionUpdatePolicy) {
         if (solutionUpdatePolicy == SolutionUpdatePolicy.NO_UPDATE) {
             throw new IllegalArgumentException(
-                    "Can not call %s.update() with this solutionUpdatePolicy (%s)."
+                    "Cannot call %s.update() with this solutionUpdatePolicy (%s), since it would do nothing."
                             .formatted(this.getClass().getSimpleName(), solutionUpdatePolicy));
         }
         return callScoreDirector("Solution update", solution, solutionUpdatePolicy,
@@ -86,11 +86,11 @@ private <Result_> Result_ callScoreDirector(String feature, Solution_ solution,
             if (solutionUpdatePolicy.isScoreUpdateEnabled()) {
                 var score = scoreDirector.calculateScore();
                 if (score.isInvalid()) {
-                    var inconsistentEntities = scoreDirector.getInconsistentEntities();
+                    var inconsistentEntities = scoreDirector.computeInconsistentEntities();
                     throw new InconsistentSolutionException(feature, nonNullSolution, inconsistentEntities);
                 }
-            } else if (!scoreDirector.isLastVariableUpdateWasSuccessful()) {
-                var inconsistentEntities = scoreDirector.getInconsistentEntities();
+            } else if (!scoreDirector.isLastVariableUpdateSuccessful()) {
+                var inconsistentEntities = scoreDirector.computeInconsistentEntities();
                 throw new InconsistentSolutionException(feature, nonNullSolution, inconsistentEntities);
             }
             return function.apply(scoreDirector);
@@ -121,7 +121,7 @@ public ScoreAnalysis<Score_> analyze(Solution_ solution, ScoreAnalysisFetchPolic
         var enterpriseService =
                 TimefoldSolverEnterpriseService.loadOrFail(TimefoldSolverEnterpriseService.Feature.SCORE_ANALYSIS);
         var currentScore = (Score_) scoreDirectorFactory.getSolutionDescriptor().getScore(solution);
-        var analysis = callScoreDirector("Solution analysis", solution, solutionUpdatePolicy,
+        var analysis = callScoreDirector("Score analysis", solution, solutionUpdatePolicy,
                 scoreDirector -> enterpriseService.analyze(scoreDirector.calculateScore(),
                         scoreDirector.getConstraintMatchTotalMap(), fetchPolicy),
                 ConstraintMatchPolicy.match(fetchPolicy), false);