Optimize splitting lines with many rules.

lib/src/rule/argument.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.argument;
 
 import '../chunk.dart';
 import 'rule.dart';
 
 /// Base class for a rule that handles argument or parameter lists.
 abstract class ArgumentRule extends Rule {
   /// The rule used to split collections in the argument list, if any.
-  final Rule _collectionRule;
+  Rule _collectionRule;
 
   /// If true, then inner rules that are written will force this rule to split.
   ///
   /// Temporarily disabled while writing collectio arguments so that they can be
   /// multi-line without forcing the whole argument list to split.
   bool _trackInnerRules = true;
 
   /// Don't split when an inner collection rule splits.
   bool get splitsOnInnerRules => _trackInnerRules;
 
   /// Creates a new rule for a positional argument list.
   ///
   /// If [_collectionRule] is given, it is the rule used to split the
   /// collections in the list.
   ArgumentRule(this._collectionRule);
 
-  Iterable<Rule> get constrainedRules {
-    var rules = super.constrainedRules;
-    if (_collectionRule != null) {
-      rules = rules.toList()..add(_collectionRule);
+  void addConstrainedRules(Set<Rule> rules) {
+    if (_collectionRule != null) rules.add(_collectionRule);
+  }
+
+  void forgetUnusedRules() {
+    super.forgetUnusedRules();
+    if (_collectionRule != null && _collectionRule.index == null) {
+      _collectionRule = null;
     }
-
-    return rules;
   }
 
   /// Called before a collection argument is written.
   ///
   /// Disables tracking inner rules while a collection argument is written.
   void beforeCollection() {
     assert(_trackInnerRules == true);
     _trackInnerRules = false;
   }
 
@@ skipping 14 matching lines @@
   /// If there are named arguments following these positional ones, this will
   /// be their rule.
   Rule _namedArgsRule;
 
   /// Creates a new rule for a positional argument list.
   ///
   /// If [collectionRule] is given, it is the rule used to split the collection
   /// arguments in the list.
   PositionalRule(Rule collectionRule) : super(collectionRule);
 
-  Iterable<Rule> get constrainedRules {
-    var rules = super.constrainedRules;
-    if (_namedArgsRule != null) {
-      rules = rules.toList()..add(_namedArgsRule);
+  void addConstrainedRules(Set<Rule> rules) {
+    if (_namedArgsRule != null) rules.add(_namedArgsRule);
+  }
+
+  void forgetUnusedRules() {
+    super.forgetUnusedRules();
+    if (_namedArgsRule != null && _namedArgsRule.index == null) {
+      _namedArgsRule = null;
     }
-
-    return rules;
   }
 
   /// Remembers [chunk] as containing the split that occurs right before an
   /// argument in the list.
   void beforeArgument(Chunk chunk) {
     _arguments.add(chunk);
   }
 
   /// Remembers that [rule] is the [NamedArgsRule] immediately following this
   /// positional argument list.
@@ skipping 27 matching lines @@
 
 /// Split rule for a call with a single positional argument (which may or may
 /// not be a collection argument.)
 class SinglePositionalRule extends PositionalRule {
   int get numValues => 2;
 
   /// If there is only a single non-collection argument, allow it to split
   /// internally without forcing a split before the argument.
   final bool splitsOnInnerRules;
 
-  bool hack = false;
-
   /// Creates a new rule for a positional argument list.
   ///
   /// If [collectionRule] is given, it is the rule used to split the
   /// collections in the list. If [splitsOnInnerRules] is `true`, then we will
   /// split before the argument if the argument itself contains a split.
   SinglePositionalRule(Rule collectionRule, {bool splitsOnInnerRules})
       : super(collectionRule),
         splitsOnInnerRules =
             splitsOnInnerRules != null ? splitsOnInnerRules : false;
 
@@ skipping 182 matching lines @@
     // If we aren't splitting any args, we can split the collection.
     if (value == 0) return null;
 
     // Split before all of the arguments, even the collections, so don't let
     // them split.
     return 0;
   }
 
   String toString() => "Named${super.toString()}";
 }