anchor.diff:            if (_ruleImplications[suffixRule].contains(prefixRule)) {
               updatedValues[suffixRule] = 0;
             }
  +        }
  +      }
  +    }
  +
  +    // We may be creating a new prefix that does not begin a line if we are
  +    // adding a new unsplit chunk to [prefix]. However, the split that *did*
  +    // begin this line may still imply something about the suffix. Add that in
  +    // here.
  +    if (previousSplit != null) {
  +      for (var suffixRule in suffixRules) {
  +        // If we already have a harder constraint, keep it.
  +        if (updatedValues.containsKey(suffixRule)) continue;
  +
  +        if (_ruleImplications[previousSplit].contains(suffixRule)) {
  +          updatedValues[suffixRule] = -1;
           }
         }
       }
  
positive.code:     // Seed with the direct implications.
      for (var rule in rules) {
        _ruleImplications[rule] = rule.implies.toSet();
      }
  
      // TODO(rnystrom): This is a hotspot right now. Can we optimize it? One
      // idea is to renumber the rule IDs to be their index in the rule set/list.
      // That would let us avoid the map and directly index.
      hasPath(int from, int to) => _ruleImplications[rules[from]].contains(rules[to]);
  
      // Calculate the transitive closure.
      for (var i = 0; i < rules.length; i++) {
  
negative.code:             updatedValues[suffixRule] = -1;
            }
          }
        } else {
          // We also need to consider the backwards case, where a later rule in
          // the suffix implies a rule in the prefix. If that happens, and the
          // prefix rule did not split, then we can't let the suffix rule that
          // implies it split either since that would violate the implication.
          for (var suffixRule in suffixRules) {
            // If we already have a harder constraint, keep it.
            if (updatedValues.containsKey(suffixRule)) continue;
  