New, simpler and faster line splitter.

lib/src/rule/rule.dart

 // Copyright (c) 2015, 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.
 
 library dart_style.src.rule.rule;
 
 import '../chunk.dart';
 import '../fast_hash.dart';
 
 /// A constraint that determines the different ways a related set of chunks may
 /// be split.
 abstract class Rule extends FastHash {
   /// The number of different states this rule can be in.
   ///
   /// Each state determines which set of chunks using this rule are split and
   /// which aren't. Values range from zero to one minus this. Value zero
   /// always means "no chunks are split" and increasing values by convention
   /// mean increasingly undesirable splits.
   int get numValues;
 
   /// The rule value that forces this rule into its maximally split state.
   ///
   /// By convention, this is the highest of the range of allowed values.
   int get fullySplitValue => numValues - 1;
 
   int get cost => Cost.normal;
 
-  /// The span of [Chunk]s that were written while this rule was still in
-  /// effect.
-  ///
-  /// This is used to tell which rules should be pre-emptively split if their
-  /// contents are too long. This may be a wider range than the set of chunks
-  /// enclosed by chunks whose rule is this one. A rule may still be on the
-  /// list of open rules for a while after its last chunk is written.
-  // TODO(rnystrom): These are only used by preemption which is kind of hacky.
-  // Remove this if preemption is redone.
-  int start;
-  int end;
+  /// During line splitting [LineSplitter] sets this to the index of this
+  /// rule in its list of rules.
+  int index;
 
   /// The other [Rule]s that "surround" this one (and care about that fact).
   ///
   /// In many cases, if a split occurs inside an expression, surrounding rules
   /// also want to split too. For example, a split in the middle of an argument
   /// forces the entire argument list to also split.
   ///
   /// This tracks those relationships. If this rule splits, (sets its value to
   /// [fullySplitValue]) then all of the outer rules will also be set to their
   /// fully split value.
@@ skipping 30 matching lines @@
   /// null to not constrain other.
   int constrain(int value, Rule other) {
     // By default, any implied rule will be fully split if this one is fully
     // split.
     if (value == 0) return null;
     if (_outerRules.contains(other)) return other.fullySplitValue;
 
     return null;
   }
 
-  /// Like [constrain], but in the other direction.
-  ///
-  /// If [other] has [otherValue], returns the constrained value this rule may
-  /// have, or `null` if any value is allowed.
-  int reverseConstrain(int otherValue, Rule other) {
-    // If [other] did not fully split, then we can't split either if us
-    // splitting implies that it should have.
-    if (otherValue == other.fullySplitValue) return null;
-    if (_outerRules.contains(other)) return 0;
-
-    return null;
-  }
-
   String toString() => "$id";
 }
 
 /// A rule that always splits a chunk.
 class HardSplitRule extends Rule {
   int get numValues => 1;
 
   /// It's always going to be applied, so there's no point in penalizing it.
   ///
   /// Also, this avoids doubled counting in literal blocks where there is both
@@ skipping 20 matching lines @@
 
   SimpleRule({int cost, bool splitsOnInnerRules})
       : cost = cost != null ? cost : Cost.normal,
         splitsOnInnerRules =
             splitsOnInnerRules != null ? splitsOnInnerRules : true;
 
   bool isSplit(int value, Chunk chunk) => value == 1;
 
   String toString() => "Simple${super.toString()}";
 }