Optimize splitting lines with many rules.

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
@@ skipping 23 matching lines @@
   /// 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.
   ///
   /// This contains all direct as well as transitive relationships. If A
   /// contains B which contains C, C's outerRules contains both B and A.
-  Iterable<Rule> get outerRules => _outerRules;
   final Set<Rule> _outerRules = new Set<Rule>();
 
   /// Adds [inner] as an inner rule of this rule if it cares about inner rules.
   ///
   /// When an inner rule splits, it forces any surrounding outer rules to also
   /// split.
   void contain(Rule inner) {
     if (!splitsOnInnerRules) return;
     inner._outerRules.add(this);
   }
@@ skipping 16 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;
   }
 
+  /// A protected method for subclasses to add the rules that they constrain
+  /// to [rules].
+  ///
+  /// Called by [Rule] the first time [constrainedRules] is accessed.
+  void addConstrainedRules(Set<Rule> rules) {}
+
+  /// Discards constraints on any rule that doesn't have an index.
+  ///
+  /// This is called by [LineSplitter] after it has indexed all of the in-use
+  /// rules. A rule may end up with a constraint on a rule that's no longer
+  /// used by any chunk. This can happen if the rule gets hardened, or if it
+  /// simply never got used by a chunk. For example, a rule for splitting an
+  /// empty list of metadata annotations.
+  ///
+  /// This removes all of those.
+  void forgetUnusedRules() {
+    _outerRules.retainWhere((rule) => rule.index != null);
+
+    // Clear the cached ones too.
+    _constrainedRules = null;
+    _allConstrainedRules = null;
+  }
+
   /// The other [Rule]s that this rule places immediate constraints on.
-  Iterable<Rule> get constrainedRules => _outerRules;
+  Set<Rule> get constrainedRules {
+    // Lazy initialize this on first use. Note: Assumes this is only called
+    // after the chunks have been written and any constraints have been wired
+    // up.
+    if (_constrainedRules == null) {
+      _constrainedRules = _outerRules.toSet();
+      addConstrainedRules(_constrainedRules);
+    }
+
+    return _constrainedRules;
+  }
+  Set<Rule> _constrainedRules;
 
   /// The transitive closure of all of the rules this rule places constraints
   /// on, directly or indirectly, including itself.
   Set<Rule> get allConstrainedRules {
     if (_allConstrainedRules == null) {
       visit(Rule rule) {
         if (_allConstrainedRules.contains(rule)) return;
 
         _allConstrainedRules.add(rule);
         rule.constrainedRules.forEach(visit);
@@ skipping 41 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()}";
 }