Optimize certain operations (#1206)

* _compareScore change

* Mark spans in _calculateCost instead of using set

* Mark NestingLevels in _calculateSplits instead of using set

* Missing file and renames

* Change and add comments

* Feedback

Author: jensjoha

lib/src/chunk.dart

@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 import 'fast_hash.dart';
+import 'marking_scheme.dart';
 import 'nesting_level.dart';
 import 'rule/rule.dart';
 
@@ -294,7 +295,11 @@ class OpenSpan {
 /// This is a wrapper around the cost so that spans have unique identities.
 /// This way we can correctly avoid paying the cost multiple times if the same
 /// span is split by multiple chunks.
-class Span extends FastHash {
+///
+/// Spans can be marked during processing in an algorithm but should be left
+/// unmarked when the algorithm finishes to make marking work in subsequent
+/// calls.
+class Span extends FastHash with Markable {
   /// The cost applied when the span is split across multiple lines or `null`
   /// if the span is for a multisplit.
   final int cost;

lib/src/line_splitting/solve_state.dart

@@ -272,17 +272,23 @@ class SolveState {
   void _calculateSplits() {
     // Figure out which expression nesting levels got split and need to be
     // assigned columns.
-    var usedNestingLevels = <NestingLevel>{};
+    var usedNestingLevels = <NestingLevel>[];
     for (var i = 0; i < _splitter.chunks.length; i++) {
       var chunk = _splitter.chunks[i];
       if (chunk.rule.isSplit(getValue(chunk.rule), chunk)) {
-        usedNestingLevels.add(chunk.nesting);
-        chunk.nesting.clearTotalUsedIndent();
+        var nesting = chunk.nesting;
+        if (nesting.mark()) {
+          usedNestingLevels.add(nesting);
+          nesting.clearTotalUsedIndent();
+        }
       }
     }
 
     for (var nesting in usedNestingLevels) {
-      nesting.refreshTotalUsedIndent(usedNestingLevels);
+      nesting.refreshTotalUsedIndent();
+    }
+    for (var nesting in usedNestingLevels) {
+      nesting.unmark();
     }
 
     _splits = SplitSet(_splitter.chunks.length);
@@ -340,10 +346,11 @@ class SolveState {
       start = end;
     }
 
-    // The set of spans that contain chunks that ended up splitting. We store
-    // these in a set so a span's cost doesn't get double-counted if more than
-    // one split occurs in it.
-    var splitSpans = <Span>{};
+    // The list of spans that contain chunks that ended up splitting. These are
+    // made unique by marking the spans during the run, adding them to this list
+    // to be able to unmark them again. We have to keep track of uniqueness to
+    // avoid double-counting if more than one split occurs in it.
+    var splitSpans = <Span>[];
 
     // The nesting level of the chunk that ended the previous line.
     NestingLevel? previousNesting;
@@ -354,7 +361,12 @@ class SolveState {
       if (_splits.shouldSplitAt(i)) {
         endLine(i);
 
-        splitSpans.addAll(chunk.spans);
+        for (var span in chunk.spans) {
+          if (span.mark()) {
+            splitSpans.add(span);
+            cost += span.cost;
+          }
+        }
 
         // Do not allow sequential lines to have the same indentation but for
         // different reasons. In other words, don't allow different expressions
@@ -408,9 +420,9 @@ class SolveState {
       if (value != Rule.unsplit) cost += rule.cost;
     });
 
-    // Add the costs for the spans containing splits.
+    // Unmark spans again so they're ready for another run.
     for (var span in splitSpans) {
-      cost += span.cost;
+      span.unmark();
     }
 
     // Finish the last line.

lib/src/line_splitting/solve_state_queue.dart

@@ -88,8 +88,11 @@ class SolveStateQueue {
 
   /// Compares the overflow and cost of [a] to [b].
   int _compareScore(SolveState a, SolveState b) {
-    if (a.splits.cost != b.splits.cost) {
-      return a.splits.cost.compareTo(b.splits.cost);
+    var aCost = a.splits.cost;
+    var bCost = b.splits.cost;
+    if (aCost != bCost) {
+      if (aCost < bCost) return -1;
+      return 1;
     }
 
     return a.overflowChars.compareTo(b.overflowChars);

lib/src/marking_scheme.dart

@@ -0,0 +1,20 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// A mixin for marking classes.
+mixin Markable {
+  bool _isMarked = false;
+
+  bool mark() {
+    if (_isMarked) return false;
+    _isMarked = true;
+    return true;
+  }
+
+  bool get isMarked => _isMarked;
+
+  void unmark() {
+    _isMarked = false;
+  }
+}

lib/src/nesting_level.dart

@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'fast_hash.dart';
+import 'marking_scheme.dart';
 
 /// A single level of expression nesting.
 ///
@@ -19,7 +20,11 @@ import 'fast_hash.dart';
 /// indented relative to the outer expression. It's almost always
 /// [Indent.expression], but cascades are special magic snowflakes and use
 /// [Indent.cascade].
-class NestingLevel extends FastHash {
+///
+/// NestingLEvels can be marked during processing in an algorithm but should be
+/// left unmarked when the algorithm finishes to make marking work in subsequent
+/// calls.
+class NestingLevel extends FastHash with Markable {
   /// The nesting level surrounding this one, or `null` if this is represents
   /// top level code in a block.
   final NestingLevel? parent;
@@ -56,19 +61,19 @@ class NestingLevel extends FastHash {
   }
 
   /// Calculates the total amount of indentation from this nesting level and
-  /// all of its parents assuming only [usedNesting] levels are in use.
-  void refreshTotalUsedIndent(Set<NestingLevel> usedNesting) {
+  /// all of its parents assuming only marked levels are in use.
+  void refreshTotalUsedIndent() {
     var totalIndent = _totalUsedIndent;
     if (totalIndent != null) return;
 
     totalIndent = 0;
 
     if (parent != null) {
-      parent!.refreshTotalUsedIndent(usedNesting);
+      parent!.refreshTotalUsedIndent();
       totalIndent += parent!.totalUsedIndent;
     }
 
-    if (usedNesting.contains(this)) totalIndent += indent;
+    if (isMarked) totalIndent += indent;
 
     _totalUsedIndent = totalIndent;
   }