Removed fixed dependencies

packages/html/lib/dom.dart

 /// A simple tree API that results from parsing html. Intended to be compatible
 /// with dart:html, but it is missing many types and APIs.
 library dom;
 
 // TODO(jmesserly): lots to do here. Originally I wanted to generate this using
 // our Blink IDL generator, but another idea is to directly use the excellent
 // http://dom.spec.whatwg.org/ and http://html.spec.whatwg.org/ and just
 // implement that.
 
 import 'dart:collection';
@@ skipping 724 matching lines @@
       removeAt(index);
       insertAll(index, value.nodes);
     } else {
       this[index].parentNode = null;
       super[index] = _setParent(value);
     }
   }
 
   // TODO(jmesserly): These aren't implemented in DOM _NodeListImpl, see
   // http://code.google.com/p/dart/issues/detail?id=5371
-  void setRange(int start, int rangeLength, List<Node> from,
+  void setRange(int start, int rangeLength, Iterable<Node> from,
       [int startFrom = 0]) {
-    if (from is NodeList) {
+    List<Node> from_ = from as List<Node>;
+    if (from_ is NodeList) {
       // Note: this is presumed to make a copy
-      from = from.sublist(startFrom, startFrom + rangeLength);
+      from_ = from_.sublist(startFrom, startFrom + rangeLength);
     }
     // Note: see comment in [addAll]. We need to be careful about the order of
     // operations if [from] is also a NodeList.
     for (int i = rangeLength - 1; i >= 0; i--) {
-      this[start + i] = from[startFrom + i];
+      this[start + i] = from_[startFrom + i];
     }
   }
 
   void replaceRange(int start, int end, Iterable<Node> newContents) {
     removeRange(start, end);
     insertAll(start, newContents);
   }
 
   void removeRange(int start, int rangeLength) {
     for (int i = start; i < rangeLength; i++) this[i].parentNode = null;
     super.removeRange(start, rangeLength);
   }
 
-  void removeWhere(bool test(Element e)) {
+  void removeWhere(bool test(Node e)) {
     for (var node in where(test)) {
       node.parentNode = null;
     }
     super.removeWhere(test);
   }
 
-  void retainWhere(bool test(Element e)) {
+  void retainWhere(bool test(Node e)) {
     for (var node in where((n) => !test(n))) {
       node.parentNode = null;
     }
     super.retainWhere(test);
   }
 
   void insertAll(int index, Iterable<Node> collection) {
     // Note: we need to be careful how we copy nodes. See note in addAll.
     var list = _flattenDocFragments(collection);
     for (var node in list.reversed) _setParent(node);
     super.insertAll(index, list);
   }
 
-  _flattenDocFragments(Iterable<Node> collection) {
+  List<Node> _flattenDocFragments(Iterable<Node> collection) {
     // Note: this function serves two purposes:
     //  * it flattens document fragments
     //  * it creates a copy of [collections] when `collection is NodeList`.
-    var result = [];
+    var result = <Node>[];
     for (var node in collection) {
       if (node is DocumentFragment) {
         result.addAll(node.nodes);
       } else {
         result.add(node);
       }
     }
     return result;
   }
 }
 
 /// An indexable collection of a node's descendants in the document tree,
 /// filtered so that only elements are in the collection.
 // TODO(jmesserly): this was copied from dart:html
 // TODO(jmesserly): "implements List<Element>" is a workaround for analyzer bug.
 class FilteredElementList extends IterableBase<Element> with ListMixin<Element>
     implements List<Element> {
-  final Node _node;
   final List<Node> _childNodes;
 
   /// Creates a collection of the elements that descend from a node.
   ///
   /// Example usage:
   ///
   ///     var filteredElements = new FilteredElementList(query("#container"));
   ///     // filteredElements is [a, b, c].
   FilteredElementList(Node node)
-      : _childNodes = node.nodes,
-        _node = node;
+      : _childNodes = node.nodes;
+
 
   // We can't memoize this, since it's possible that children will be messed
   // with externally to this class.
   //
   // TODO(nweiz): we don't always need to create a new list. For example
   // forEach, every, any, ... could directly work on the _childNodes.
   List<Element> get _filtered =>
       new List<Element>.from(_childNodes.where((n) => n is Element));
 
   void forEach(void f(Element element)) {
@@ skipping 20 matching lines @@
   void add(Element value) {
     _childNodes.add(value);
   }
 
   void addAll(Iterable<Element> iterable) {
     for (Element element in iterable) {
       add(element);
     }
   }
 
-  bool contains(Element element) {
+  bool contains(Object element) {
     return element is Element && _childNodes.contains(element);
   }
 
   Iterable<Element> get reversed => _filtered.reversed;
 
   void sort([int compare(Element a, Element b)]) {
     throw new UnsupportedError('TODO(jacobr): should we impl?');
   }
 
   void setRange(int start, int end, Iterable<Element> iterable,
@@ skipping 20 matching lines @@
   }
 
   Element removeLast() {
     final result = this.last;
     if (result != null) {
       result.remove();
     }
     return result;
   }
 
-  Iterable map(f(Element element)) => _filtered.map(f);
+  Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(Element element)) => _filtered.map(f);
   Iterable<Element> where(bool f(Element element)) => _filtered.where(f);
-  Iterable expand(Iterable f(Element element)) => _filtered.expand(f);
+  Iterable/*<T>*/ expand/*<T>*/(Iterable/*<T>*/ f(Element element)) =>
+      _filtered.expand(f);
 
   void insert(int index, Element value) {
     _childNodes.insert(index, value);
   }
 
   void insertAll(int index, Iterable<Element> iterable) {
     _childNodes.insertAll(index, iterable);
   }
 
   Element removeAt(int index) {
@@ skipping 11 matching lines @@
         return true;
       }
     }
     return false;
   }
 
   Element reduce(Element combine(Element value, Element element)) {
     return _filtered.reduce(combine);
   }
 
-  dynamic fold(dynamic initialValue,
-      dynamic combine(dynamic previousValue, Element element)) {
+  dynamic/*=T*/ fold/*<T>*/(var/*=T*/ initialValue,
+      dynamic/*=T*/ combine(var/*=T*/ previousValue, Element element)) {
     return _filtered.fold(initialValue, combine);
   }
 
   bool every(bool f(Element element)) => _filtered.every(f);
   bool any(bool f(Element element)) => _filtered.any(f);
   List<Element> toList({bool growable: true}) =>
       new List<Element>.from(this, growable: growable);
   Set<Element> toSet() => new Set<Element>.from(this);
   Element firstWhere(bool test(Element value), {Element orElse()}) {
     return _filtered.firstWhere(test, orElse: orElse);
@@ skipping 11 matching lines @@
     return this[index];
   }
 
   bool get isEmpty => _filtered.isEmpty;
   int get length => _filtered.length;
   Element operator [](int index) => _filtered[index];
   Iterator<Element> get iterator => _filtered.iterator;
   List<Element> sublist(int start, [int end]) => _filtered.sublist(start, end);
   Iterable<Element> getRange(int start, int end) =>
       _filtered.getRange(start, end);
-  int indexOf(Element element, [int start = 0]) =>
+  // TODO(sigmund): this should be typed Element, but we currently run into a
+  // bug where ListMixin<E>.indexOf() expects Object as the argument.
+  int indexOf(element, [int start = 0]) =>
       _filtered.indexOf(element, start);
 
-  int lastIndexOf(Element element, [int start = null]) {
+  // TODO(sigmund): this should be typed Element, but we currently run into a
+  // bug where ListMixin<E>.lastIndexOf() expects Object as the argument.
+  int lastIndexOf(element, [int start = null]) {
     if (start == null) start = length - 1;
     return _filtered.lastIndexOf(element, start);
   }
 
   Element get first => _filtered.first;
 
   Element get last => _filtered.last;
 
   Element get single => _filtered.single;
 }
@@ skipping 10 matching lines @@
 
 class _ConcatTextVisitor extends TreeVisitor {
   final _str = new StringBuffer();
 
   String toString() => _str.toString();
 
   visitText(Text node) {
     _str.write(node.data);
   }
 }