Add a script for determining which DOM methods correspond to which HTML methods.

client/html/release/html.dart

 #library('html');
 
 #import('dart:dom', prefix:'dom');
 // Copyright (c) 2011, 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.
 
 // DO NOT EDIT
 // Auto-generated Dart HTML library.
 
@@ skipping 16809 matching lines @@
 class _CSSMatrixFactoryProvider {
 
   factory CSSMatrix([String spec = '']) {
     return new CSSMatrixWrappingImplementation._wrap(
         new dom.WebKitCSSMatrix(spec));
   }
 }
 
 class _PointFactoryProvider {
 
+  /** @domName Window.createWebKitPoint */
   factory Point(num x, num y) {
     return new PointWrappingImplementation._wrap(new dom.WebKitPoint(x, y));
   }
 }
 // Copyright (c) 2011, 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.
 
 // Iterator for lists with fixed size.
 class _FixedSizeListIterator<T> extends _VariableSizeListIterator<T> {
@@ skipping 5605 matching lines @@
   final List<ClientRect> clientRects = const <ClientRect>[];
 
   const EmptyElementRect();
 }
 
 class DocumentFragmentWrappingImplementation extends NodeWrappingImplementation implements DocumentFragment {
   ElementList _elements;
 
   DocumentFragmentWrappingImplementation._wrap(ptr) : super._wrap(ptr) {}
 
+  /** @domName Document.createDocumentFragment */
   factory DocumentFragmentWrappingImplementation() {
     return new DocumentFragmentWrappingImplementation._wrap(
             dom.document.createDocumentFragment());
   }
 
   factory DocumentFragmentWrappingImplementation.html(String html) {
     var fragment = new DocumentFragment();
     fragment.innerHTML = html;
     return fragment;
   }
@@ skipping 223 matching lines @@
 class DocumentWrappingImplementation extends ElementWrappingImplementation implements Document {
 
   final _documentPtr;
 
   DocumentWrappingImplementation._wrap(this._documentPtr, ptr) : super._wrap(ptr) {
     // We have to set the back ptr on the document as well as the documentElement
     // so that it is always simple to detect when an existing wrapper exists.
     _documentPtr.dartObjectLocalStorage = this;
   }
 
+  /** @domName HTMLDocument.activeElement */
   Element get activeElement() => LevelDom.wrapElement(_documentPtr.activeElement);
 
   Node get parent() => null;
 
+  /** @domName Document.body */
   Element get body() => LevelDom.wrapElement(_documentPtr.body);
 
+  /** @domName Document.body */
   void set body(Element value) { _documentPtr.body = LevelDom.unwrap(value); }
 
+  /** @domName Document.charset */
   String get charset() => _documentPtr.charset;
 
+  /** @domName Document.charset */
   void set charset(String value) { _documentPtr.charset = value; }
 
+  /** @domName Document.cookie */
   String get cookie() => _documentPtr.cookie;
 
+  /** @domName Document.cookie */
   void set cookie(String value) { _documentPtr.cookie = value; }
 
+  /** @domName Document.defaultView */
   Window get window() => LevelDom.wrapWindow(_documentPtr.defaultView);
 
+  /** @domName HTMLDocument.designMode */
   void set designMode(String value) { _documentPtr.designMode = value; }
 
+  /** @domName Document.domain */
   String get domain() => _documentPtr.domain;
 
+  /** @domName Document.head */
   HeadElement get head() => LevelDom.wrapHeadElement(_documentPtr.head);
 
+  /** @domName Document.lastModified */
   String get lastModified() => _documentPtr.lastModified;
 
+  /** @domName Document.readyState */
   String get readyState() => _documentPtr.readyState;
 
+  /** @domName Document.referrer */
   String get referrer() => _documentPtr.referrer;
 
+  /** @domName Document.styleSheets */
   StyleSheetList get styleSheets() => LevelDom.wrapStyleSheetList(_documentPtr.styleSheets);
 
+  /** @domName Document.title */
   String get title() => _documentPtr.title;
 
+  /** @domName Document.title */
   void set title(String value) { _documentPtr.title = value; }
 
+  /** @domName Document.webkitHidden */
   bool get webkitHidden() => _documentPtr.webkitHidden;
 
+  /** @domName Document.webkitVisibilityState */
   String get webkitVisibilityState() => _documentPtr.webkitVisibilityState;
 
+  /** @domName Document.caretRangeFromPoint */
   Future<Range> caretRangeFromPoint([int x = null, int y = null]) {
     return _createMeasurementFuture(
         () => LevelDom.wrapRange(_documentPtr.caretRangeFromPoint(x, y)),
         new Completer<Range>());
   }
 
+  /** @domName Document.createElement */
   Element createElement([String tagName = null]) {
     return LevelDom.wrapElement(_documentPtr.createElement(tagName));
   }
 
+  /** @domName Document.createEvent */
   Event createEvent([String eventType = null]) {
     return LevelDom.wrapEvent(_documentPtr.createEvent(eventType));
   }
 
+  /** @domName Document.elementFromPoint */
   Future<Element> elementFromPoint([int x = null, int y = null]) {
     return _createMeasurementFuture(
         () => LevelDom.wrapElement(_documentPtr.elementFromPoint(x, y)),
         new Completer<Element>());
   }
 
+  /** @domName Document.execCommand */
   bool execCommand([String command = null, bool userInterface = null, String value = null]) {
     return _documentPtr.execCommand(command, userInterface, value);
   }
 
+  /** @domName Document.getCSSCanvasContext */
   CanvasRenderingContext getCSSCanvasContext(String contextId, String name,
                                              int width, int height) {
     return LevelDom.wrapCanvasRenderingContext(_documentPtr.getCSSCanvasContext(contextId, name, width, height));
   }
 
+  /** @domName Document.queryCommandEnabled */
   bool queryCommandEnabled([String command = null]) {
     return _documentPtr.queryCommandEnabled(command);
   }
 
+  /** @domName Document.queryCommandIndeterm */
   bool queryCommandIndeterm([String command = null]) {
     return _documentPtr.queryCommandIndeterm(command);
   }
 
+  /** @domName Document.queryCommandState */
   bool queryCommandState([String command = null]) {
     return _documentPtr.queryCommandState(command);
   }
 
+  /** @domName Document.queryCommandSupported */
   bool queryCommandSupported([String command = null]) {
     return _documentPtr.queryCommandSupported(command);
   }
 
+  /** @domName Document.queryCommandValue */
   String queryCommandValue([String command = null]) {
     return _documentPtr.queryCommandValue(command);
   }
 
   String get manifest() => _ptr.manifest;
 
   void set manifest(String value) { _ptr.manifest = value; }
 
   DocumentEvents get on() {
     if (_on === null) {
@@ skipping 584 matching lines @@
   bool containsValue(String value) {
     final attributes = _element.attributes;
     for (int i = 0, len = attributes.length; i < len; i++) {
       if(value == attributes.item(i).value) {
         return true;
       }
     }
     return false;
   }
 
+  /** @domName Element.hasAttribute */
   bool containsKey(String key) {
     return _element.hasAttribute(key);
   }
 
+  /** @domName Element.getAttribute */
   String operator [](String key) {
     return _element.getAttribute(key);
   }
 
+  /** @domName Element.setAttribute */
   void operator []=(String key, String value) {
     _element.setAttribute(key, value);
   }
 
   String putIfAbsent(String key, String ifAbsent()) {
     if (!containsKey(key)) {
       this[key] = ifAbsent();
     }
   }
 
+  /** @domName Element.removeAttribute */
   String remove(String key) {
     _element.removeAttribute(key);
   }
 
   void clear() {
     final attributes = _element.attributes;
     for (int i = attributes.length - 1; i >= 0; i--) {
       _element.removeAttribute(attributes.item(i).name);
     }
   }
@@ skipping 108 matching lines @@
   }
 
   String toString() => "($left, $top, $width, $height)";
 }
 
 // TODO(jacobr): we cannot currently be lazy about calculating the client
 // rects as we must perform all measurement queries at a safe point to avoid
 // triggering unneeded layouts.
 /**
  * All your element measurement needs in one place
+ * @domName none
  */
 class ElementRectWrappingImplementation implements ElementRect {
   final ClientRect client;
   final ClientRect offset;
   final ClientRect scroll;
 
   // TODO(jacobr): should we move these outside of ElementRect to avoid the
   // overhead of computing them every time even though they are rarely used.
   // This should be type dom.ClientRect but that fails on dartium. b/5522629
   final _boundingClientRect; 
@@ skipping 213 matching lines @@
   }
 
   bool contains(Node element) {
     return _ptr.contains(LevelDom.unwrap(element));
   }
 
   void focus() {
     _ptr.focus();
   }
 
+  /** @domName HTMLElement.insertAdjacentElement */
   Element insertAdjacentElement([String where = null, Element element = null]) {
     return LevelDom.wrapElement(_ptr.insertAdjacentElement(where, LevelDom.unwrap(element)));
   }
 
+  /** @domName HTMLElement.insertAdjacentHTML */
   void insertAdjacentHTML([String position_OR_where = null, String text = null]) {
     _ptr.insertAdjacentHTML(position_OR_where, text);
   }
 
+  /** @domName HTMLElement.insertAdjacentText */
   void insertAdjacentText([String where = null, String text = null]) {
     _ptr.insertAdjacentText(where, text);
   }
 
   Element query(String selectors) {
     // TODO(jacobr): scope fix.
     return LevelDom.wrapElement(_ptr.querySelector(selectors));
   }
 
   ElementList queryAll(String selectors) {
@@ skipping 14 matching lines @@
   }
 
   bool matchesSelector([String selectors = null]) {
     return _ptr.webkitMatchesSelector(selectors);
   }
 
   void set scrollLeft(int value) { _ptr.scrollLeft = value; }
  
   void set scrollTop(int value) { _ptr.scrollTop = value; }
 
+  /** @domName getClientRects */
   Future<ElementRect> get rect() {
     return _createMeasurementFuture(
         () => new ElementRectWrappingImplementation(_ptr),
         new Completer<ElementRect>());
   }
 
   Future<CSSStyleDeclaration> get computedStyle() {
      // TODO(jacobr): last param should be null, see b/5045788
      return getComputedStyle('');
   }
 
+  /** @domName Window.getComputedStyle */
   Future<CSSStyleDeclaration> getComputedStyle(String pseudoElement) {
     return _createMeasurementFuture(() =>
         LevelDom.wrapCSSStyleDeclaration(
             dom.window.getComputedStyle(_ptr, pseudoElement)),
         new Completer<CSSStyleDeclaration>());
   }
 
   ElementEvents get on() {
     if (_on === null) {
       _on = new ElementEventsImplementation._wrap(_ptr);
@@ skipping 1454 matching lines @@
 
   bool some(bool f(Node element)) {
     for(Node element in this) {
       if (f(element)) {
         return true;
       }
     };
     return false;
   }
 
+  /** @domName Node.hasChildNodes */
   bool isEmpty() {
     return _node.hasChildNodes();
   }
 
   int get length() {
     return _childNodes.length;
   }
 
   Node operator [](int index) {
     return LevelDom.wrapNode(_childNodes[index]);
   }
 
   void operator []=(int index, Node value) {
     _childNodes[index] = LevelDom.unwrap(value);
   }
 
    void set length(int newLength) {
      throw new UnsupportedOperationException('');
    }
 
+  /** @domName Node.appendChild */
   Node add(Node value) {
     _node.appendChild(LevelDom.unwrap(value));
     return value;
   }
 
   Node addLast(Node value) {
     _node.appendChild(LevelDom.unwrap(value));
     return value;
   }
 
@@ skipping 99 matching lines @@
   }
 
   Node remove() {
     // TODO(jacobr): should we throw an exception if parent is already null?
     if (_ptr.parentNode !== null) {
       _ptr.parentNode.removeChild(_ptr);
     }
     return this;
   }
 
+  /** @domName Node.contains */
   bool contains(Node otherNode) {
     // TODO: Feature detect and use built in.
     while (otherNode != null && otherNode != this) {
       otherNode = otherNode.parent;
     }
     return otherNode == this;
   }
 
   // TODO(jacobr): remove when/if List supports a method similar to
   // insertBefore or we switch NodeList to implement LinkedList rather than
@@ skipping 105 matching lines @@
 
   bool get verticalOverflow();
 }
 // Copyright (c) 2011, 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.
 
 class OverflowEventWrappingImplementation extends EventWrappingImplementation implements OverflowEvent {
   OverflowEventWrappingImplementation._wrap(ptr) : super._wrap(ptr);
 
+  /** @domName OverflowEvent.initOverflowEvent */
   factory OverflowEventWrappingImplementation(int orient,
       bool horizontalOverflow, bool verticalOverflow) {
     final e = dom.document.createEvent("OverflowEvent");
     e.initOverflowEvent(orient, horizontalOverflow, verticalOverflow);
     return LevelDom.wrapOverflowEvent(e);
   }
 
   bool get horizontalOverflow() => _ptr.horizontalOverflow;
 
   int get orient() => _ptr.orient;
@@ skipping 198 matching lines @@
     return LevelDom.wrapTextEvent(e);
   }
 
   String get data() => _ptr.data;
 }
 // Copyright (c) 2011, 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.
 
 class TextWrappingImplementation extends CharacterDataWrappingImplementation implements Text {
+  /** @domName Document.createTextNode */
   factory TextWrappingImplementation(String content) {
     return new TextWrappingImplementation._wrap(
         dom.document.createTextNode(content));
   }
 
   TextWrappingImplementation._wrap(ptr) : super._wrap(ptr);
 
   String get wholeText() => _ptr.wholeText;
 
   Text replaceWholeText([String content = null]) {
@@ skipping 42 matching lines @@
 
   TouchList get touches();
 }
 // Copyright (c) 2011, 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.
 
 class TouchEventWrappingImplementation extends UIEventWrappingImplementation implements TouchEvent {
   TouchEventWrappingImplementation._wrap(ptr) : super._wrap(ptr);
 
-  TouchEvent(TouchList touches, TouchList targetTouches,
+  factory TouchEvent(TouchList touches, TouchList targetTouches,
       TouchList changedTouches, String type, Window view, int screenX,
       int screenY, int clientX, int clientY, [bool ctrlKey = false,
       bool altKey = false, bool shiftKey = false, bool metaKey = false]) {
     final e = dom.document.createEvent("TouchEvent");
     e.initTouchEvent(LevelDom.unwrap(touches), LevelDom.unwrap(targetTouches),
         LevelDom.unwrap(changedTouches), type, LevelDom.unwrap(view), screenX,
         screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey);
     return LevelDom.wrapTouchEvent(e);
   }
 
@@ skipping 696 matching lines @@
   EventListenerList get unLoad() => _get('unload');
   EventListenerList get volumeChange() => _get('volumechange');
   EventListenerList get waiting() => _get('waiting');
   EventListenerList get animationEnd() => _get('webkitAnimationEnd');
   EventListenerList get animationIteration() => _get('webkitAnimationIteration');
   EventListenerList get animationStart() => _get('webkitAnimationStart');
   EventListenerList get transitionEnd() => _get('webkitTransitionEnd');
   EventListenerList get contentLoaded() => _get('DOMContentLoaded');
 }
 
+/** @domName Window */
 class WindowWrappingImplementation extends EventTargetWrappingImplementation implements Window {
   WindowWrappingImplementation._wrap(ptr) : super._wrap(ptr);
 
   DOMApplicationCache get applicationCache() => LevelDom.wrapDOMApplicationCache(_ptr.applicationCache);
 
   Navigator get clientInformation() => LevelDom.wrapNavigator(_ptr.clientInformation);
 
   void set clientInformation(Navigator value) { _ptr.clientInformation = LevelDom.unwrap(value); }
 
   bool get closed() => _ptr.closed;
@@ skipping 958 matching lines @@
   EventListenerList get load() => _get('load');
   EventListenerList get loadStart() => _get('loadstart');
   EventListenerList get progress() => _get('progress');
   EventListenerList get readyStateChange() => _get('readystatechange');
 }
 
 class XMLHttpRequestWrappingImplementation extends EventTargetWrappingImplementation implements XMLHttpRequest {
   XMLHttpRequestWrappingImplementation._wrap(
       dom.XMLHttpRequest ptr) : super._wrap(ptr);
 
+  /** @domName Window.createXMLHttpRequest */
   factory XMLHttpRequestWrappingImplementation() {
     return new XMLHttpRequestWrappingImplementation._wrap(
         new dom.XMLHttpRequest());
   }
 
   factory XMLHttpRequestWrappingImplementation.getTEMPNAME(String url,
       onSuccess(XMLHttpRequest request)) {
     final request = new XMLHttpRequest();
     request.open('GET', url, true);
 
@@ skipping 91 matching lines @@
     _ptr.setRequestHeader(header, value);
   }
 
   XMLHttpRequestEvents get on() {
     if (_on === null) {
       _on = new XMLHttpRequestEventsImplementation._wrap(_ptr);
     }
     return _on;
   }
 }