Cleanup attributes generation in dart:html.

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 254 matching lines @@
     "Node.set:nodeValue",
     "Node.get:CDATA_SECTION_NODE",
     "Node.get:nodeName",
     "Node.lookupPrefix",
     "Node.get:PROCESSING_INSTRUCTION_NODE",
     "IFrameElement.get:contentDocument",
     "Window.get:frameElement",
     ])
 
 _html_library_custom = set([
-    'IFrameElement.get:contentWindow',
-    'Window.get:document',
-    'Window.get:top',
-    'Window.get:location',
-    'Window.set:location',
+    'IFrameElement.contentWindow',
+    'Window.document',
+    'Window.top',
+    'Window.location',
     'Window.open',
     'IDBDatabase.transaction',
     ])
 
 # This map controls merging of interfaces in dart:html library.
 # All constants, attributes, and operations of merged interface (key) are
 # added to target interface (value). All references to the merged interface
 # (e.g. parameter types, return types, parent interfaces) are replaced with
 # target interface. There are two important restrictions:
 # 1) Merged and target interfaces shouldn't have common members, otherwise there
@@ skipping 650 matching lines @@
         merged_interface = self._database.GetInterface(merged_interface)
         self.AddMembers(merged_interface)
     self._backend = old_backend
 
   def AddIndexer(self, element_type):
     self._backend.AddIndexer(element_type)
 
   def AmendIndexer(self, element_type):
     self._backend.AmendIndexer(element_type)
 
-  def AddAttribute(self, attribute):
-    self._backend.AddAttribute(attribute)
-
-    getter = attribute
-    setter = attribute if not IsReadOnly(attribute) else None
-    dom_name = DartDomNameOfAttribute(getter)
-    html_getter_name = self._shared.RenameInHtmlLibrary(
+  def AddAttribute(self, attribute, is_secondary=False):
+    dom_name = DartDomNameOfAttribute(attribute)
+    html_name = self._shared.RenameInHtmlLibrary(
       self._interface.id, dom_name, 'get:')
-    html_setter_name = self._shared.RenameInHtmlLibrary(
-      self._interface.id, dom_name, 'set:')
-
-    if not html_getter_name or self._shared.IsPrivate(html_getter_name):
-      getter = None
-    if not html_setter_name or self._shared.IsPrivate(html_setter_name):
-      setter = None
-    if not getter and not setter:
+    if not html_name or self._shared.IsPrivate(html_name):
       return
 
+
+    html_setter_name = self._shared.RenameInHtmlLibrary(
+        self._interface.id, dom_name, 'set:')
+    read_only = IsReadOnly(attribute) or not html_setter_name
+
     # We don't yet handle inconsistent renames of the getter and setter yet.
-    if html_getter_name and html_setter_name:
-      assert html_getter_name == html_setter_name
+    assert(not html_setter_name or html_name == html_setter_name)
 
-    self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
-        DOMINTERFACE=getter.doc_js_interface_name,
-        DOMNAME=dom_name)
-    if (getter and setter and
-        getter.type.id == setter.type.id):
-      self._members_emitter.Emit('\n  $TYPE $NAME;\n',
-                                 NAME=html_getter_name,
-                                 TYPE=self._shared.DartType(getter.type.id))
-      return
-    if getter and not setter:
-      self._members_emitter.Emit('\n  final $TYPE $NAME;\n',
-                                 NAME=html_getter_name,
-                                 TYPE=self._shared.DartType(getter.type.id))
-      return
-    raise Exception('Unexpected getter/setter combination %s %s' %
-                    (getter, setter))
+    if not is_secondary:
+      self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
+          DOMINTERFACE=attribute.doc_js_interface_name,
+          DOMNAME=dom_name)
+      modifier = 'final ' if read_only else ''
+      self._members_emitter.Emit('\n  $MODIFIER$TYPE $NAME;\n',
+                                 MODIFIER=modifier,
+                                 NAME=html_name,
+                                 TYPE=self._shared.DartType(attribute.type.id))
+    self._backend.AddAttribute(attribute, html_name, read_only)
 
-  def AddOperation(self, info):
+  def AddSecondaryAttribute(self, interface, attribute):
+    self._backend.SecondaryContext(interface)
+    self.AddAttribute(attribute, True)
+
+  def AddOperation(self, info, is_secondary=False):
     """
     Arguments:
       operations - contains the overloads, one or more operations with the same
         name.
     """
     html_name = self._shared.RenameInHtmlLibrary(
         self._interface.id, info.name)
-    if html_name and not self._shared.IsPrivate(html_name):
+    if html_name and not self._shared.IsPrivate(html_name) and not is_secondary:
       self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
           DOMINTERFACE=info.overloads[0].doc_js_interface_name,
           DOMNAME=info.name)
 
       self._members_emitter.Emit('\n'
                                  '  $TYPE $NAME($PARAMS);\n',
                                  TYPE=self._shared.DartType(info.type_name),
                                  NAME=html_name,
                                  PARAMS=info.ParametersInterfaceDeclaration(
                                         self._shared.DartType))
     self._backend.AddOperation(info)
 
   def AddStaticOperation(self, info):
     self._backend.AddStaticOperation(info)
 
+  def AddSecondaryOperation(self, interface, info):
+    self._backend.SecondaryContext(interface)
+    self.AddOperation(info, True)
+
   def FinishInterface(self):
-    self._backend.AddSecondaryMembers(self._interface)
     self._backend.FinishInterface()
 
   def AddConstant(self, constant):
     type = TypeOrNothing(DartType(constant.type.id), constant.type.id)
     self._members_emitter.Emit('\n  static final $TYPE$NAME = $VALUE;\n',
                                NAME=constant.id,
                                TYPE=type,
                                VALUE=constant.value)
     self._backend.AddConstant(constant)
 
@@ skipping 51 matching lines @@
         '\n   */'
         '\n  $TYPE get on();\n',
         TYPE=events_interface)
 
     self._implementation_members_emitter.Emit(
         '\n  $TYPE get on() =>\n    new $TYPE(this);\n',
         TYPE=events_class)
 
 
 class HtmlGeneratorDummyBackend(object):
-  def AddAttribute(self, attribute):
+  def AddAttribute(self, attribute, html_name, read_only):
     pass
 
   def AddOperation(self, info):
     pass
 
 
 # ------------------------------------------------------------------------------
 
 # TODO(jmesserly): inheritance is probably not the right way to factor this long
 # term, but it makes merging better for now.
@@ skipping 144 matching lines @@
             '  }\n',
             TYPE=self._NarrowInputType(element_type))
 
     # TODO(sra): Use separate mixins for mutable implementations of List<T>.
     # TODO(sra): Use separate mixins for typed array implementations of List<T>.
     if self._interface.id != 'NodeList':
       template_file = 'immutable_list_mixin.darttemplate'
       template = self._system._templates.Load(template_file)
       self._members_emitter.Emit(template, E=self._shared.DartType(element_type))
 
-  def AddAttribute(self, attribute):
-    getter = attribute
-    setter = attribute if not IsReadOnly(attribute) else None
-    dom_name = DartDomNameOfAttribute(getter or setter)
-    html_getter_name = None
-    if not self._shared.IsCustomInHtmlLibrary(
-        self._interface, dom_name, 'get:'):
-      html_getter_name = self._shared.RenameInHtmlLibrary(
-          self._interface.id, dom_name, 'get:',
-          implementation_class=True)
-    html_setter_name = None
-    if not self._shared.IsCustomInHtmlLibrary(
-        self._interface, dom_name, 'set:'):
-      html_setter_name = self._shared.RenameInHtmlLibrary(
-          self._interface.id, dom_name, 'set:',
-          implementation_class=True)
-
-    if not html_getter_name:
-      getter = None
-    if not html_setter_name:
-      setter = None
-
-    if not getter and not setter:
+  def AddAttribute(self, attribute, html_name, read_only):
+    if self._shared.IsCustomInHtmlLibrary(self._interface, attribute.id):
       return
 
-    if ((getter and html_getter_name != getter.id) or
-        (setter and html_setter_name != setter.id)):
-      if getter:
-        self._AddRenamingGetter(getter, html_getter_name)
-      if setter:
-        self._AddRenamingSetter(setter, html_setter_name)
+    if attribute.id != html_name:
+      self._AddRenamingGetter(attribute, html_name)
+      if not read_only:
+        self._AddRenamingSetter(attribute, html_name)
       return
 
-    # If the (getter, setter) pair is shadowing, we can't generate a shadowing
+    # If the attribute is shadowing, we can't generate a shadowing
     # field (Issue 1633).
-    (super_getter, super_getter_interface) = self._FindShadowedAttribute(getter, _merged_html_interfaces)
-    (super_setter, super_setter_interface) = self._FindShadowedAttribute(setter, _merged_html_interfaces)
-    if super_getter or super_setter:
-      if getter and not setter and super_getter and not super_setter:
-        if getter.type.id == super_getter.type.id:
-          # Compatible getter, use the superclass property.  This works because
-          # JavaScript will do its own dynamic dispatch.
-          output_type = getter and self._NarrowOutputType(getter.type.id)
+    (super_attribute, super_attribute_interface) = self._FindShadowedAttribute(attribute, _merged_html_interfaces)
+    if super_attribute:
+      if read_only:
+        if attribute.type.id == super_attribute.type.id:
+          # Compatible attribute, use the superclass property.  This works
+          # because JavaScript will do its own dynamic dispatch.
           self._members_emitter.Emit(
               '\n'
               '  // Use implementation from $SUPER.\n'
               '  // final $TYPE $NAME;\n',
-              SUPER=super_getter_interface,
-              NAME=DartDomNameOfAttribute(getter),
-              TYPE=output_type)
+              SUPER=super_attribute_interface,
+              NAME=DartDomNameOfAttribute(attribute),
+              TYPE=self._NarrowOutputType(attribute.type.id))
           return
 
       self._members_emitter.Emit('\n  // Shadowing definition.')
-      self._AddAttributeUsingProperties(getter, setter)
+      self._AddAttributeUsingProperties(attribute, read_only)
       return
 
-    output_type = getter and self._NarrowOutputType(getter.type.id)
-    input_type = setter and self._NarrowInputType(setter.type.id)
-    if getter and setter and input_type == output_type:
+    output_type = self._NarrowOutputType(attribute.type.id)
+    input_type = self._NarrowInputType(attribute.type.id)
+    if not read_only:
       self._members_emitter.Emit(
           '\n  $TYPE $NAME;\n',
-          NAME=DartDomNameOfAttribute(getter),
+          NAME=DartDomNameOfAttribute(attribute),
           TYPE=output_type)
-      return
-    if getter and not setter:
+    else:
       self._members_emitter.Emit(
           '\n  final $TYPE $NAME;\n',
-          NAME=DartDomNameOfAttribute(getter),
+          NAME=DartDomNameOfAttribute(attribute),
           TYPE=output_type)
-      return
-    self._AddAttributeUsingProperties(getter, setter)
 
-  def _AddAttributeUsingProperties(self, getter, setter):
-    if getter:
-      self._AddGetter(getter)
-    if setter:
-      self._AddSetter(setter)
+  def _AddAttributeUsingProperties(self, attribute, read_only):
+    self._AddGetter(attribute)
+    if not read_only:
+      self._AddSetter(attribute)
 
   def _AddGetter(self, attr):
     self._AddRenamingGetter(attr, DartDomNameOfAttribute(attr))
 
   def _AddSetter(self, attr):
     self._AddRenamingSetter(attr, DartDomNameOfAttribute(attr))
 
   def _AddRenamingGetter(self, attr, html_name):
     return_type = self._NarrowOutputType(attr.type.id)
     self._members_emitter.Emit(
@@ skipping 84 matching lines @@
             Collect(database.GetInterface(parent.type.id),
                     seen, collected)
 
   inheritance_closure = {}
   for interface in database.GetInterfaces():
     seen = set()
     collected = []
     Collect(interface, seen, collected)
     inheritance_closure[interface.id] = collected
   return inheritance_closure