Partially migrate from old getter syntax to new one.

lib/dom/scripts/systemhtml.py

 #!/usr/bin/python
 # 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.
 
 """This module provides shared functionality for the system to generate
 Dart:html APIs from the IDL database."""
 
 import emitter
 
@@ skipping 698 matching lines @@
         'class $CLASSNAME extends $SUPER implements $INTERFACE {\n'
         '  $CLASSNAME(_ptr) : super(_ptr);\n'
         '$!MEMBERS}\n',
         CLASSNAME=events_class,
         INTERFACE=events_interface,
         SUPER=parent_events_class)
 
     event_attrs = DomToHtmlEvents(self._html_interface_name, event_attrs)
     for event_name in event_attrs:
       if event_name in _html_event_names:
-        events_members.Emit('\n  EventListenerList get $NAME();\n',
+        events_members.Emit('\n  EventListenerList get $NAME;\n',
           NAME=_html_event_names[event_name])
         implementation_events_members.Emit(
             "\n"
-            "  EventListenerList get $NAME() => this['$DOM_NAME'];\n",
+            "  EventListenerList get $NAME => this['$DOM_NAME'];\n",
             NAME=_html_event_names[event_name],
             DOM_NAME=event_name)
       else:
         raise Exception('No known html even name for event: ' + event_name)
 
   def _EmitEventGetter(self, events_interface, events_class):
     self._members_emitter.Emit(
         '\n  /**'
         '\n   * @domName EventTarget.addEventListener, '
         'EventTarget.removeEventListener, EventTarget.dispatchEvent'
         '\n   */'
-        '\n  $TYPE get on();\n',
+        '\n  $TYPE get on;\n',
         TYPE=events_interface)
 
     self._implementation_members_emitter.Emit(
-        '\n  $TYPE get on() =>\n    new $TYPE(this);\n',
+        '\n  $TYPE get on =>\n    new $TYPE(this);\n',
         TYPE=events_class)
 
 
 class HtmlGeneratorDummyBackend(object):
   def AddAttribute(self, attribute, html_name, read_only):
     pass
 
   def AddOperation(self, info, html_name):
     pass
 
@@ skipping 99 matching lines @@
         template,
         FACTORYPROVIDER=factory_provider,
         CONSTRUCTOR=self._html_interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
         NAMED_CONSTRUCTOR=constructor_info.name or self._html_interface_name,
         ARGUMENTS=constructor_info.ParametersAsArgumentList())
 
   def AddIndexer(self, element_type):
     """Adds all the methods required to complete implementation of List."""
     # We would like to simply inherit the implementation of everything except
-    # get length(), [], and maybe []=.  It is possible to extend from a base
+    # length, [], and maybe []=.  It is possible to extend from a base
     # array implementation class only when there is no other implementation
     # inheritance.  There might be no implementation inheritance other than
     # DOMBaseWrapper for many classes, but there might be some where the
     # array-ness is introduced by a non-root interface:
     #
     #   interface Y extends X, List<T> ...
     #
     # In the non-root case we have to choose between:
     #
     #   class YImpl extends XImpl { add List<T> methods; }
@@ skipping 88 matching lines @@
     self._AddRenamingGetter(attribute, html_name)
     if not read_only:
       self._AddRenamingSetter(attribute, html_name)
 
   def _AddRenamingGetter(self, attr, html_name):
     conversion = self._OutputConversion(attr.type.id, attr.id)
     if conversion:
       return self._AddConvertingGetter(attr, html_name, conversion)
     return_type = self._NarrowOutputType(attr.type.id)
     self._members_emitter.Emit(
-        '\n  $TYPE get $HTML_NAME() native "return this.$NAME;";\n',
+        '\n  $TYPE get $HTML_NAME native "return this.$NAME;";\n',
         HTML_NAME=html_name,
         NAME=attr.id,
         TYPE=return_type)
 
   def _AddRenamingSetter(self, attr, html_name):
     conversion = self._InputConversion(attr.type.id, attr.id)
     if conversion:
       return self._AddConvertingSetter(attr, html_name, conversion)
     self._members_emitter.Emit(
         '\n  void set $HTML_NAME($TYPE value)'
         ' native "this.$NAME = value;";\n',
         HTML_NAME=html_name,
         NAME=attr.id,
         TYPE=self._NarrowInputType(attr.type.id))
 
   def _AddConvertingGetter(self, attr, html_name, conversion):
     self._members_emitter.Emit(
-        '\n  $RETURN_TYPE get $HTML_NAME() => $CONVERT(this._$(HTML_NAME));'
-        '\n  $NATIVE_TYPE get _$HTML_NAME() native "return this.$NAME;";'
+        '\n  $RETURN_TYPE get $HTML_NAME => $CONVERT(this._$(HTML_NAME));'
+        '\n  $NATIVE_TYPE get _$HTML_NAME native "return this.$NAME;";'
         '\n',
         CONVERT=conversion.function_name,
         HTML_NAME=html_name,
         NAME=attr.id,
         RETURN_TYPE=conversion.output_type,
         NATIVE_TYPE=conversion.input_type)
 
   def _AddConvertingSetter(self, attr, html_name, conversion):
     self._members_emitter.Emit(
         '\n  void set $HTML_NAME($INPUT_TYPE value) {'
@@ skipping 235 matching lines @@
     return HtmlDart2JSClassGenerator(self, interface)
 
   def GenerateLibraries(self, dart_files):
     self._GenerateLibFile(
         'html_dart2js.darttemplate',
         os.path.join(self._output_dir, 'html_dart2js.dart'),
         dart_files)
 
   def Finish(self):
     pass