BestFirstSearch: invert {always -> possibly}Better

scalafmt-core/shared/src/main/scala/org/scalafmt/config/ScalafmtOptimizer.scala

@@ -22,9 +22,9 @@ import metaconfig._
   * @param pruneSlowStates
   *   Eliminate solutions that move slower than other solutions.
   *   - If a solution reaches a point X first and other solution that reaches
-  *     the same point later, the first solution is preferred if it can be
-  *     verified to be always better (see
-  *     [[org.scalafmt.internal.State.alwaysBetter]]).
+  *     the same point later, the second solution is ignored unless it can be
+  *     verified not to be worse (see
+  *     [[org.scalafmt.internal.State.possiblyBetter]]).
   *   - Note. This affects the output positively because it breaks a tie between
   *     two equally expensive solutions by eliminating the slower one.
   *   - Example: solution 1 is preferred even though both solutions cost the

scalafmt-core/shared/src/main/scala/org/scalafmt/internal/BestFirstSearch.scala

@@ -51,7 +51,7 @@ private class BestFirstSearch private (range: Set[Range])(implicit
   def shouldEnterState(curr: State): Boolean = keepSlowStates ||
     curr.policy.noDequeue ||
     // TODO(olafur) document why/how this optimization works.
-    !best.get(curr.depth).exists(_.alwaysBetter(curr))
+    best.get(curr.depth).forall(curr.possiblyBetter)
 
   private def getBlockCloseToRecurse(ft: FormatToken, stop: Token)(implicit
       style: ScalafmtConfig,

scalafmt-core/shared/src/main/scala/org/scalafmt/internal/State.scala

@@ -35,8 +35,8 @@ final case class State(
   @inline
   def mod: Modification = modExt.mod
 
-  def alwaysBetter(other: State): Boolean = this.cost <= other.cost &&
-    this.indentation <= other.indentation
+  def possiblyBetter(other: State): Boolean = this.cost < other.cost ||
+    this.indentation < other.indentation
 
   /** Calculates next State given split at tok.
     */