Update generic comment syntax

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';
+
 import 'package:source_span/source_span.dart';
 
+import 'dom_parsing.dart';
+import 'parser.dart';
 import 'src/constants.dart';
 import 'src/css_class_set.dart';
 import 'src/list_proxy.dart';
 import 'src/query_selector.dart' as query;
 import 'src/token.dart';
 import 'src/tokenizer.dart';
-import 'dom_parsing.dart';
-import 'parser.dart';
 
 export 'src/css_class_set.dart' show CssClassSet;
 
 // TODO(jmesserly): this needs to be replaced by an AttributeMap for attributes
 // that exposes namespace info.
 class AttributeName implements Comparable {
   /// The namespace prefix, e.g. `xlink`.
   final String prefix;
 
   /// The attribute name, e.g. `title`.
@@ skipping 72 matching lines @@
 // This doesn't exist as an interface in the spec, but it's useful to merge
 // common methods from these:
 // http://dom.spec.whatwg.org/#interface-document
 // http://dom.spec.whatwg.org/#element
 abstract class _ElementAndDocument implements _ParentNode {
   // TODO(jmesserly): could be faster, should throw on invalid tag/class names.
 
   List<Element> getElementsByTagName(String localName) =>
       querySelectorAll(localName);
 
-  List<Element> getElementsByClassName(String classNames) => querySelectorAll(
-      classNames.splitMapJoin(' ',
+  List<Element> getElementsByClassName(String classNames) =>
+      querySelectorAll(classNames.splitMapJoin(' ',
           onNonMatch: (m) => m.isNotEmpty ? '.$m' : m, onMatch: (m) => ''));
 }
 
 /// Really basic implementation of a DOM-core like Node.
 abstract class Node {
   static const int ATTRIBUTE_NODE = 2;
   static const int CDATA_SECTION_NODE = 4;
   static const int COMMENT_NODE = 8;
   static const int DOCUMENT_FRAGMENT_NODE = 11;
   static const int DOCUMENT_NODE = 9;
@@ skipping 160 matching lines @@
     tokenizer.moveNext();
     var token = tokenizer.current as StartTagToken;
 
     if (token.attributeSpans == null) return; // no attributes
 
     for (var attr in token.attributeSpans) {
       var offset = sourceSpan.start.offset;
       _attributeSpans[attr.name] =
           sourceSpan.file.span(offset + attr.start, offset + attr.end);
       if (attr.startValue != null) {
-        _attributeValueSpans[attr.name] = sourceSpan.file.span(
-            offset + attr.startValue, offset + attr.endValue);
+        _attributeValueSpans[attr.name] = sourceSpan.file
+            .span(offset + attr.startValue, offset + attr.endValue);
       }
     }
   }
 
   _clone(Node shallowClone, bool deep) {
     if (deep) {
       for (var child in nodes) {
         shallowClone.append(child.clone(true));
       }
     }
@@ skipping 93 matching lines @@
 
   DocumentType clone(bool deep) => new DocumentType(name, publicId, systemId);
 }
 
 class Text extends Node {
   /// The text node's data, stored as either a String or StringBuffer.
   /// We support storing a StringBuffer here to support fast [appendData].
   /// It will flatten back to a String on read.
   var _data;
 
-  Text(String data) : _data = data != null ? data : '', super._();
+  Text(String data)
+      : _data = data != null ? data : '',
+        super._();
 
   int get nodeType => Node.TEXT_NODE;
 
   String get data => _data = _data.toString();
   set data(String value) {
     _data = value != null ? value : '';
   }
 
   String toString() => '"$data"';
 
@@ skipping 48 matching lines @@
     'thead': 'table',
     'track': 'audio',
   };
 
   // TODO(jmesserly): this is from dart:html _ElementFactoryProvider...
   // TODO(jmesserly): have a look at fixing some things in dart:html, in
   // particular: is the parent tag map complete? Is it faster without regexp?
   // TODO(jmesserly): for our version we can do something smarter in the parser.
   // All we really need is to set the correct parse state.
   factory Element.html(String html) {
-
     // TODO(jacobr): this method can be made more robust and performant.
     // 1) Cache the dummy parent elements required to use innerHTML rather than
     //    creating them every call.
     // 2) Verify that the html does not contain leading or trailing text nodes.
     // 3) Verify that the html does not contain both <head> and <body> tags.
     // 4) Detatch the created element from its dummy parent.
     String parentTag = 'div';
     String tag;
     final match = _START_TAG_REGEXP.firstMatch(html);
     if (match != null) {
@@ skipping 310 matching lines @@
       }
     }
     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>
+class FilteredElementList extends IterableBase<Element>
+    with ListMixin<Element>
     implements List<Element> {
   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;
-
+  FilteredElementList(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 61 matching lines @@
   }
 
   Element removeLast() {
     final result = this.last;
     if (result != null) {
       result.remove();
     }
     return result;
   }
 
-  Iterable/*<T>*/ map/*<T>*/(/*=T*/ 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/*<T>*/ expand/*<T>*/(Iterable/*<T>*/ 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/*=T*/ fold/*<T>*/(var/*=T*/ initialValue,
-      dynamic/*=T*/ combine(var/*=T*/ previousValue, Element element)) {
+  T fold<T>(T initialValue, T combine(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 13 matching lines @@
 
   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);
   // 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 indexOf(element, [int start = 0]) => _filtered.indexOf(element, start);
 
   // 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;
 
@@ skipping 14 matching lines @@
 
 class _ConcatTextVisitor extends TreeVisitor {
   final _str = new StringBuffer();
 
   String toString() => _str.toString();
 
   visitText(Text node) {
     _str.write(node.data);
   }
 }