Partially migrate from old getter syntax to new one.

lib/dom/templates/html/impl/impl_Element.darttemplate

 // Copyright (c) 2012, 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.
 
 // TODO(jacobr): use _Lists.dart to remove some of the duplicated
 // functionality.
 class _ChildrenElementList implements ElementList {
   // Raw Element.
   final _ElementImpl _element;
   final _HTMLCollectionImpl _childElements;
 
   _ChildrenElementList._wrap(_ElementImpl element)
     : _childElements = element.$dom_children,
       _element = element;
 
   List<Element> _toList() {
     final output = new List(_childElements.length);
     for (int i = 0, len = _childElements.length; i < len; i++) {
       output[i] = _childElements[i];
     }
     return output;
   }
 
-  _ElementImpl get first() {
+  _ElementImpl get first {
     return _element.$dom_firstElementChild;
   }
 
   void forEach(void f(Element element)) {
     for (_ElementImpl element in _childElements) {
       f(element);
     }
   }
 
   ElementList filter(bool f(Element element)) {
@@ skipping 29 matching lines @@
     for (Element el in this) {
       out.add(f(el));
     }
     return out;
   }
 
   bool isEmpty() {
     return _element.$dom_firstElementChild == null;
   }
 
-  int get length() {
+  int get length {
     return _childElements.length;
   }
 
   _ElementImpl operator [](int index) {
     return _childElements[index];
   }
 
   void operator []=(int index, _ElementImpl value) {
     _element.$dom_replaceChild(value, _childElements[index]);
   }
@@ skipping 67 matching lines @@
 
 // TODO(jacobr): this is an inefficient implementation but it is hard to see
 // a better option given that we cannot quite force NodeList to be an
 // ElementList as there are valid cases where a NodeList JavaScript object
 // contains Node objects that are not Elements.
 class _FrozenElementList implements ElementList {
   final List<Node> _nodeList;
 
   _FrozenElementList._wrap(this._nodeList);
 
-  Element get first() {
+  Element get first {
     return _nodeList[0];
   }
 
   void forEach(void f(Element element)) {
     for (Element el in this) {
       f(el);
     }
   }
 
   Collection map(f(Element element)) {
@@ skipping 25 matching lines @@
     for(Element element in this) {
       if (f(element)) {
         return true;
       }
     };
     return false;
   }
 
   bool isEmpty() => _nodeList.isEmpty();
 
-  int get length() => _nodeList.length;
+  int get length => _nodeList.length;
 
   Element operator [](int index) => _nodeList[index];
 
   void operator []=(int index, Element value) {
     throw const UnsupportedOperationException('');
   }
 
   void set length(int newLength) {
     _nodeList.length = newLength;
   }
@@ skipping 154 matching lines @@
     final values = new List<String>(attributes.length);
     for (int i = 0, len = attributes.length; i < len; i++) {
       values[i] = attributes[i].value;
     }
     return values;
   }
 
   /**
    * The number of {key, value} pairs in the map.
    */
-  int get length() {
+  int get length {
     return _element.$dom_attributes.length;
   }
 
   /**
    * Returns true if there is no {key, value} pair in the map.
    */
   bool isEmpty() {
     return length == 0;
   }
 }
@@ skipping 54 matching lines @@
   Collection<String> getValues() {
     final values = new List<String>();
     $dom_attributes.forEach((String key, String value) {
       if (_matches(key)) {
         values.add(value);
       }
     });
     return values;
   }
 
-  int get length() => getKeys().length;
+  int get length => getKeys().length;
 
   // TODO: Use lazy iterator when it is available on Map.
   bool isEmpty() => length == 0;
 
   // Helpers.
   String _attr(String key) => 'data-$key';
   bool _matches(String key) => key.startsWith('data-');
   String _strip(String key) => key.substring(5);
 }
 
@@ skipping 17 matching lines @@
   Collection map(f(String element)) => _read().map(f);
 
   Collection<String> filter(bool f(String element)) => _read().filter(f);
 
   bool every(bool f(String element)) => _read().every(f);
 
   bool some(bool f(String element)) => _read().some(f);
 
   bool isEmpty() => _read().isEmpty();
 
-  bool get isFrozen() => false;
+  bool get isFrozen => false;
 
-  int get length() =>_read().length;
+  int get length =>_read().length;
 
   // interface Collection - END
 
   // interface Set - BEGIN
   bool contains(String value) => _read().contains(value);
 
   void add(String value) {
     // TODO - figure out if we need to do any validation here
     // or if the browser natively does enough
     _modify((s) => s.add(value));
@@ skipping 92 matching lines @@
     List list = new List.from(s);
     return Strings.join(list, ' ');
   }
 }
 
 class _SimpleClientRect implements ClientRect {
   final num left;
   final num top;
   final num width;
   final num height;
-  num get right() => left + width;
-  num get bottom() => top + height;
+  num get right => left + width;
+  num get bottom => top + height;
 
   const _SimpleClientRect(this.left, this.top, this.width, this.height);
 
   bool operator ==(ClientRect other) {
     return other !== null && left == other.left && top == other.top
         && width == other.width && height == other.height;
   }
 
   String toString() => "($left, $top, $width, $height)";
 }
@@ skipping 24 matching lines @@
                                   element.$dom_offsetTop,
                                   element.$dom_offsetWidth,
                                   element.$dom_offsetHeight),
     scroll = new _SimpleClientRect(element.$dom_scrollLeft,
                                   element.$dom_scrollTop,
                                   element.$dom_scrollWidth,
                                   element.$dom_scrollHeight),
     _boundingClientRect = element.$dom_getBoundingClientRect(),
     _clientRects = element.$dom_getClientRects();
 
-  _ClientRectImpl get bounding() => _boundingClientRect;
+  _ClientRectImpl get bounding => _boundingClientRect;
 
   // TODO(jacobr): cleanup.
-  List<ClientRect> get clientRects() {
+  List<ClientRect> get clientRects {
     final out = new List(_clientRects.length);
     for (num i = 0; i < _clientRects.length; i++) {
       out[i] = _clientRects.item(i);
     }
     return out;
   }
 }
 
 class $CLASSNAME$EXTENDS$IMPLEMENTS$NATIVESPEC {
 
   /**
    * @domName Element.hasAttribute, Element.getAttribute, Element.setAttribute,
    *   Element.removeAttribute
    */
-  _ElementAttributeMap get attributes() => new _ElementAttributeMap(this);
+  _ElementAttributeMap get attributes => new _ElementAttributeMap(this);
 
   void set attributes(Map<String, String> value) {
     Map<String, String> attributes = this.attributes;
     attributes.clear();
     for (String key in value.getKeys()) {
       attributes[key] = value[key];
     }
   }
 
   void set elements(Collection<Element> value) {
     final elements = this.elements;
     elements.clear();
     elements.addAll(value);
   }
 
-  ElementList get elements() => new _ChildrenElementList._wrap(this);
+  ElementList get elements => new _ChildrenElementList._wrap(this);
 
   _ElementImpl query(String selectors) => $dom_querySelector(selectors);
 
   List<Element> queryAll(String selectors) =>
     new _FrozenElementList._wrap($dom_querySelectorAll(selectors));
 
-  _CssClassSet get classes() => new _CssClassSet(this);
+  _CssClassSet get classes => new _CssClassSet(this);
 
   void set classes(Collection<String> value) {
     _CssClassSet classSet = classes;
     classSet.clear();
     classSet.addAll(value);
   }
 
-  Map<String, String> get dataAttributes() =>
+  Map<String, String> get dataAttributes =>
     new _DataAttributeMap(attributes);
 
   void set dataAttributes(Map<String, String> value) {
     final dataAttributes = this.dataAttributes;
     dataAttributes.clear();
     for (String key in value.getKeys()) {
       dataAttributes[key] = value[key];
     }
   }
 
-  Future<ElementRect> get rect() {
+  Future<ElementRect> get rect {
     return _createMeasurementFuture(
         () => new _ElementRectImpl(this),
         new Completer<ElementRect>());
   }
 
-  Future<CSSStyleDeclaration> get computedStyle() {
+  Future<CSSStyleDeclaration> get computedStyle {
      // TODO(jacobr): last param should be null, see b/5045788
      return getComputedStyle('');
   }
 
   Future<CSSStyleDeclaration> getComputedStyle(String pseudoElement) {
     return _createMeasurementFuture(
         () => _window.$dom_getComputedStyle(this, pseudoElement),
         new Completer<CSSStyleDeclaration>());
   }
 
@@ skipping 139 matching lines @@
 
   /** @domName Document.createElement */
 $if DART2JS
   // Optimization to improve performance until the dart2js compiler inlines this
   // method.
   factory Element.tag(String tag) native "return document.createElement(tag)";
 $else
   factory Element.tag(String tag) => _document.$dom_createElement(tag);
 $endif
 }