Roll Observatory deps (charted -> ^0.3.0)

packages/dart_style/lib/src/line_splitting/rule_set.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.line_splitting.rule_set;
 
 import '../rule/rule.dart';
 
 /// An optimized data structure for storing a set of values for some rules.
 ///
 /// This conceptually behaves roughly like a `Map<Rule, int>`, but is much
 /// faster since it avoids hashing. Instead, it assumes the line splitter has
 /// provided an ordered list of [Rule]s and that each rule's [index] field has
 /// been set to point to the rule in the list.
 ///
 /// Internally, this then just stores the values in a sparse list whose indices
 /// are the indices of the rules.
 class RuleSet {
   List<int> _values;
 
   RuleSet(int numRules) : this._(new List(numRules));
 
   RuleSet._(this._values);
 
   /// Returns `true` of [rule] is bound in this set.
-  bool contains(Rule rule) => _values[rule.index] != null;
+  bool contains(Rule rule) {
+    // Treat hardened rules as implicitly bound.
+    if (rule.isHardened) return true;
 
-  /// Gets the bound value for [rule] or `0` if it is not bound.
+    return _values[rule.index] != null;
+  }
+
+  /// Gets the bound value for [rule] or [Rule.unsplit] if it is not bound.
   int getValue(Rule rule) {
+    // Hardened rules are implicitly bound.
+    if (rule.isHardened) return rule.fullySplitValue;
+
     var value = _values[rule.index];
     if (value != null) return value;
 
-    return 0;
+    return Rule.unsplit;
   }
 
   /// Invokes [callback] for each rule in [rules] with the rule's value, which
   /// will be `null` if it is not bound.
   void forEach(List<Rule> rules, callback(Rule rule, int value)) {
     var i = 0;
     for (var rule in rules) {
       var value = _values[i];
       if (value != null) callback(rule, value);
       i++;
     }
   }
 
   /// Creates a new [RuleSet] with the same bound rule values as this one.
   RuleSet clone() => new RuleSet._(_values.toList(growable: false));
 
   /// Binds [rule] to [value] then checks to see if that violates any
   /// constraints.
   ///
   /// Returns `true` if all constraints between the bound rules are valid. Even
   /// if not, this still modifies the [RuleSet].
   ///
   /// If an unbound rule gets constrained to `-1` (meaning it must split, but
   /// can split any way it wants), invokes [onSplitRule] with it.
   bool tryBind(List<Rule> rules, Rule rule, int value, onSplitRule(Rule rule)) {
+    assert(!rule.isHardened);
+
     _values[rule.index] = value;
 
     // Test this rule against the other rules being bound.
-    for (var other in rules) {
-      if (rule == other) continue;
+    for (var other in rule.constrainedRules) {
+      var otherValue;
+      // Hardened rules are implicitly bound.
+      if (other.isHardened) {
+        otherValue = other.fullySplitValue;
+      } else {
+        otherValue = _values[other.index];
+      }
 
-      var otherValue = _values[other.index];
       var constraint = rule.constrain(value, other);
 
       if (otherValue == null) {
         // The other rule is unbound, so see if we can constrain it eagerly to
         // a value now.
-        if (constraint == -1) {
+        if (constraint == Rule.mustSplit) {
           // If we know the rule has to split and there's only one way it can,
           // just bind that.
           if (other.numValues == 2) {
             if (!tryBind(rules, other, 1, onSplitRule)) return false;
           } else {
             onSplitRule(other);
           }
         } else if (constraint != null) {
           // Bind the other rule to its value and recursively propagate its
           // constraints.
           if (!tryBind(rules, other, constraint, onSplitRule)) return false;
         }
       } else {
         // It's already bound, so see if the new rule's constraint disallows
         // that value.
-        if (constraint == -1) {
-          if (otherValue == 0) return false;
+        if (constraint == Rule.mustSplit) {
+          if (otherValue == Rule.unsplit) return false;
         } else if (constraint != null) {
           if (otherValue != constraint) return false;
         }
 
         // See if the other rule's constraint allows us to use this value.
         constraint = other.constrain(otherValue, rule);
-        if (constraint == -1) {
-          if (value == 0) return false;
+        if (constraint == Rule.mustSplit) {
+          if (value == Rule.unsplit) return false;
         } else if (constraint != null) {
           if (value != constraint) return false;
         }
       }
     }
 
     return true;
   }
 
   String toString() =>
@@ skipping 41 matching lines @@
     var result = [];
     for (var i = 0; i < _columns.length; i++) {
       if (_columns[i] != null) {
         result.add("$i:${_columns[i]}");
       }
     }
 
     return result.join(" ");
   }
 }