Removed fixed dependencies

packages/dart_style/lib/src/line_splitting/solve_state.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.solve_state;
 
 import '../debug.dart' as debug;
 import '../rule/rule.dart';
 import '../whitespace.dart';
 import 'line_splitter.dart';
@@ skipping 177 matching lines @@
     var unsplitRules = _ruleValues.clone();
 
     // Walk down the rules looking for unbound ones to try.
     var triedRules = 0;
     for (var rule in _splitter.rules) {
       if (_liveRules.contains(rule)) {
         // We found one worth trying, so try all of its values.
         for (var value = 1; value < rule.numValues; value++) {
           var boundRules = unsplitRules.clone();
 
-          var mustSplitRules;
+          List<Rule> mustSplitRules;
           var valid = boundRules.tryBind(_splitter.rules, rule, value, (rule) {
             if (mustSplitRules == null) mustSplitRules = [];
             mustSplitRules.add(rule);
           });
 
           // Make sure we don't violate the constraints of the bound rules.
           if (!valid) continue;
 
           var state = new SolveState(_splitter, boundRules);
 
@@ skipping 237 matching lines @@
   }
 
   /// Lazily initializes the [_boundInUnboundLines], which is needed to compare
   /// two states for overlap.
   ///
   /// We do this lazily because the calculation is a bit slow, and is only
   /// needed when we have two states with the same score.
   void _ensureBoundRulesInUnboundLines() {
     if (_boundRulesInUnboundLines != null) return;
 
-    _boundRulesInUnboundLines = new Set();
+    _boundRulesInUnboundLines = new Set<Rule>();
 
-    var boundInLine = new Set();
+    var boundInLine = new Set<Rule>();
     var hasUnbound = false;
 
     for (var i = 0; i < _splitter.chunks.length - 1; i++) {
       if (splits.shouldSplitAt(i)) {
         if (hasUnbound) _boundRulesInUnboundLines.addAll(boundInLine);
 
         boundInLine.clear();
         hasUnbound = false;
       }
 
@@ skipping 52 matching lines @@
   void _ensureUnboundConstraints() {
     if (_unboundConstraints != null) return;
 
     // _ensureConstraints should be called first which initializes these.
     assert(_boundRules != null);
     assert(_unboundRules != null);
 
     _unboundConstraints = {};
 
     for (var unbound in _unboundRules) {
-      var disallowedValues;
+      Set<int> disallowedValues;
 
       for (var bound in unbound.constrainedRules) {
         if (!_boundRules.contains(bound)) continue;
 
         var boundValue = _ruleValues.getValue(bound);
 
         for (var value = 0; value < unbound.numValues; value++) {
           var constraint = unbound.constrain(value, bound);
 
           // If the unbound rule doesn't place any constraint on this bound
           // rule, we're fine.
           if (constraint == null) continue;
 
           // If the bound rule's value already meets the constraint it applies,
           // we don't need to track it. This way, two states that have the
           // same bound value, one of which has a satisfied constraint, are
           // still allowed to overlap.
           if (constraint == boundValue) continue;
           if (constraint == Rule.mustSplit && boundValue != Rule.unsplit) {
             continue;
           }
 
           if (disallowedValues == null) {
-            disallowedValues = new Set();
+            disallowedValues = new Set<int>();
             _unboundConstraints[unbound] = disallowedValues;
           }
 
           disallowedValues.add(value);
         }
       }
     }
   }
 
   String toString() {
@@ skipping 19 matching lines @@
 
     buffer.write("   \$${splits.cost}");
 
     if (overflowChars > 0) buffer.write(" (${overflowChars} over)");
     if (!_isComplete) buffer.write(" (incomplete)");
     if (splits == null) buffer.write(" invalid");
 
     return buffer.toString();
   }
 }