Cleanup generators

client/dom/scripts/dartgenerator.py

 #!/usr/bin/python
 # 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.
 
 """This module generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 393 matching lines @@
     self._GenerateJavaScriptExternsMonkey(database, output_dir)
     self._GenerateJavaScriptExternsWrapping(database, output_dir)
 
 
   def _ProcessInterface(self, interface, super_interface_name,
                         source_filter,
                         common_prefix):
     """."""
     _logger.info('Generating %s' % interface.id)
 
-
-    self._overloaded_types = set()
-
     dart_interface_generator = self._MakeDartInterfaceGenerator(
         interface,
         common_prefix,
         super_interface_name,
         source_filter)
 
     monkey_interface_generator = self._MakeMonkeyInterfaceGenerator(interface)
 
     wrapping_interface_generator = self._MakeWrappingImplInterfaceGenerator(
         interface,
         common_prefix,
         super_interface_name,
         source_filter)
 
     frog_interface_generator = self._MakeFrogImplInterfaceGenerator(
         interface,
         common_prefix,
         super_interface_name,
         source_filter)
 
-    dart_interface_generator.StartInterface()
-    monkey_interface_generator.StartInterface()
-    wrapping_interface_generator.StartInterface()
-    frog_interface_generator.StartInterface()
+    generators = [dart_interface_generator,
+                  monkey_interface_generator,
+                  wrapping_interface_generator,
+                  frog_interface_generator]
+
+    for generator in generators:
+      generator.StartInterface()
 
     for const in sorted(interface.constants, ConstantOutputOrder):
-      dart_interface_generator.AddConstant(const)
+      for generator in generators:
+        generator.AddConstant(const)
 
     for attr in sorted(interface.attributes, AttributeOutputOrder):
       if attr.is_fc_getter:
-        dart_interface_generator.AddGetter(attr)
-        monkey_interface_generator.AddGetter(attr)
-        wrapping_interface_generator.AddGetter(attr)
-        frog_interface_generator.AddGetter(attr)
+        for generator in generators:
+          generator.AddGetter(attr)
       elif attr.is_fc_setter:
-        dart_interface_generator.AddSetter(attr)
-        monkey_interface_generator.AddSetter(attr)
-        wrapping_interface_generator.AddSetter(attr)
-        frog_interface_generator.AddSetter(attr)
+        for generator in generators:
+          generator.AddSetter(attr)
 
     # The implementation should define an indexer if the interface directly
     # extends List.
     for parent in interface.parents:
       match = re.match(r'List<(\w*)>$', parent.type.id)
       if match:
         element_type = match.group(1)
-        monkey_interface_generator.AddIndexer(element_type)
-        wrapping_interface_generator.AddListImplementation(element_type)
-        frog_interface_generator.AddListImplementation(element_type)
+        for generator in generators:
+          generator.AddIndexer(element_type)
         break
 
     # Group overloaded operations by id
     operationsById = {}
     for operation in interface.operations:
       if operation.id not in operationsById:
         operationsById[operation.id] = []
       operationsById[operation.id].append(operation)
 
     # Generate operations
     for id in sorted(operationsById.keys()):
       operations = operationsById[id]
       info = self._AnalyzeOperation(interface, operations)
-      dart_interface_generator.AddOperation(info)
-      monkey_interface_generator.AddOperation(info)
-      wrapping_interface_generator.AddOperation(info)
-      frog_interface_generator.AddOperation(info)
+      for generator in generators:
+        generator.AddOperation(info)
 
     # With multiple inheritance, attributes and operations of non-first
     # interfaces need to be added.  Sometimes the attribute or operation is
     # defined in the current interface as well as a parent.  In that case we
     # avoid making a duplicate definition and pray that the signatures match.
 
     for parent_interface in self._TransitiveSecondaryParents(interface):
       if isinstance(interface, str):  # _IsDartCollectionType(parent_interface)
         continue
       attributes = sorted(parent_interface.attributes,
                           AttributeOutputOrder)
       for attr in attributes:
         if not self._DefinesSameAttribute(interface, attr):
           if attr.is_fc_getter:
-            monkey_interface_generator.AddSecondaryGetter(
-                parent_interface, attr)
-            wrapping_interface_generator.AddSecondaryGetter(
-                parent_interface, attr)
-            frog_interface_generator.AddSecondaryGetter(
-                parent_interface, attr)
+            for generator in generators:
+              generator.AddSecondaryGetter(parent_interface, attr)
           elif attr.is_fc_setter:
-            monkey_interface_generator.AddSecondarySetter(
-                parent_interface, attr)
-            wrapping_interface_generator.AddSecondarySetter(
-                parent_interface, attr)
-            frog_interface_generator.AddSecondarySetter(
-                parent_interface, attr)
+            for generator in generators:
+              generator.AddSecondarySetter(parent_interface, attr)
 
       # Group overloaded operations by id
       operationsById = {}
       for operation in parent_interface.operations:
         if operation.id not in operationsById:
           operationsById[operation.id] = []
         operationsById[operation.id].append(operation)
 
       # Generate operations
       for id in sorted(operationsById.keys()):
         if not any(op.id == id for op in interface.operations):
           operations = operationsById[id]
           info = self._AnalyzeOperation(interface, operations)
-          monkey_interface_generator.AddSecondaryOperation(
-              parent_interface, info)
-          wrapping_interface_generator.AddSecondaryOperation(
-              parent_interface, info)
-          frog_interface_generator.AddSecondaryOperation(
-              parent_interface, info)
+          for generator in generators:
+            generator.AddSecondaryOperation(parent_interface, info)
 
-    dart_interface_generator.FinishInterface(self._overloaded_types)
-    monkey_interface_generator.FinishInterface()
-    wrapping_interface_generator.FinishInterface()
-    frog_interface_generator.FinishInterface()
+    for generator in generators:
+      generator.FinishInterface()
     return
 
   def _DefinesSameAttribute(self, interface, attr1):
     return any(attr1.id == attr2.id
                and attr1.is_fc_getter == attr2.is_fc_getter
                and attr1.is_fc_setter == attr2.is_fc_setter
                for attr2 in interface.attributes)
 
   def _TransitiveSecondaryParents(self, interface):
     """Returns a list of all non-primary parents.
@@ skipping 27 matching lines @@
     # Given a list of overloaded arguments, choose a suitable name.
     def OverloadedName(args):
       return '_OR_'.join(sorted(set(arg.id for arg in args)))
 
     # Given a list of overloaded arguments, choose a suitable type.
     def OverloadedType(args):
       typeIds = sorted(set(arg.type.id for arg in args))
       if len(typeIds) == 1:
         return typeIds[0]
       else:
-        self._overloaded_types.add(tuple(typeIds))
         return TypeName(typeIds, interface)
 
     # Given a list of overloaded arguments, render a dart argument.
     def DartArg(args):
       filtered = filter(None, args)
       optional = any(not arg or arg.is_optional for arg in args)
       type = OverloadedType(filtered)
       name = OverloadedName(filtered)
       if optional:
         return (name, type, 'null')
@@ skipping 509 matching lines @@
 
     comment = ' extends'
     if extends:
       extends_emitter.Emit(' extends $SUPERS', SUPERS=', '.join(extends))
       comment = ','
     if suppressed_extends:
       extends_emitter.Emit(' /*$COMMENT $SUPERS */',
                            COMMENT=comment,
                            SUPERS=', '.join(suppressed_extends))
 
-  def FinishInterface(self, overloaded_types):
+  def FinishInterface(self):
     # Write snippet text that was inlined in the IDL.
     for snippet in self._interface.snippets:
       self._members_emitter.Emit('\n$LINES',
                                  LINES=IndentText(snippets.text, '  '))
 
     # TODO(vsm): Test if snippets are extra methods or extra types.
     # Since Dart doesn't permit inner types, append after the interface.
     # Consider moving these types to auxilary classes instead.
     if self._extra_snippets is not None:
       if 'interface' in self._extra_snippets:
@@ skipping 28 matching lines @@
                  VALUE=constant.value)
 
   def AddGetter(self, attr):
     self._members_emitter.Emit('\n  $TYPE get $NAME();\n',
                                NAME=attr.id, TYPE=attr.type.id)
 
   def AddSetter(self, attr):
     self._members_emitter.Emit('\n  void set $NAME($TYPE value);\n',
                                NAME=attr.id, TYPE=attr.type.id)
 
+  def AddIndexer(self, element_type):
+    # Interface inherits all operations from List<element_type>.
+    pass
+
   def AddOperation(self, info):
     """
     Arguments:
       operations - contains the overloads, one or more operations with the same
         name.
     """
     self._members_emitter.Emit('\n'
                                '  $TYPE $NAME($ARGS);\n',
                                TYPE=info.type_name,
                                NAME=info.name,
                                ARGS=info.arg_interface_declaration)
 
+  # Interfaces get secondary members directly via the superinterfaces.
+  def AddSecondaryGetter(self, attr):
+    pass
+  def AddSecondarySetter(self, attr):
+    pass
+  def AddSecondaryOperation(self, attr):
+    pass
+
 
 # Given a sorted sequence of type identifiers, return an appropriate type
 # name
 def TypeName(typeIds, interface):
   # Dynamically type this field for now.
   return 'var'
 
 
 # ------------------------------------------------------------------------------
 
@@ skipping 42 matching lines @@
     if interface.parents:
       supertype = interface.parents[0].type.id
       # FIXME: We're currently injecting List<..> and EventTarget as
       # supertypes in dart.idl. We should annotate/preserve as
       # attributes instead.  For now, this hack lets the interfaces
       # inherit, but not the classes.
       if (not _IsDartListType(supertype) and
           not supertype == 'EventTarget'):
         base = self._ImplClassName(supertype)
       if _IsDartCollectionType(supertype):
-        # List methods are injected in AddListImplementation.
+        # List methods are injected in AddIndexer.
         pass
       elif supertype == 'EventTarget':
         # Most implementors of EventTarget specify the EventListener operations
         # again.  If the operations are not specified, try to inherit from the
         # EventTarget implementation.
         #
         # Applies to MessagePort.
         if not [op for op in interface.operations if op.id == 'addEventListener']:
           base = self._ImplClassName(supertype)
       else:
@@ skipping 16 matching lines @@
         CLASS=self._class_name, BASE=base, INTERFACE=interface_name)
 
   def _ImplClassName(self, type_name):
     return '_' + type_name + 'WrappingImplementation'
 
   def FinishInterface(self):
     """."""
     pass
 
   def AddConstant(self, constant):
+    # Constants are already defined on the interface.
     pass
 
   def _MethodName(self, prefix, name):
     method_name = prefix + name
     if name in self._base_members:  # Avoid illegal Dart 'static override'.
       method_name = method_name + '_' + self._interface.id
     return method_name
 
   def AddGetter(self, attr):
     # FIXME: Instead of injecting the interface name into the method when it is
@@ skipping 48 matching lines @@
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
   def _SecondaryContext(self, interface):
     if interface is not self._current_secondary_parent:
       self._current_secondary_parent = interface
       self._members_emitter.Emit('\n  // From $WHERE\n', WHERE=interface.id)
 
-
-  def AddListImplementation(self, element_type):
+  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
     # 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> ...
     #
@@ skipping 417 matching lines @@
     #   {prototype: window.blah.blah.__proto__}
     # perhaps we should return the real constructor:
     #   window.blah.blah.constructor
     prefix = root;
     steps = []
     for accessor in accessors + ['__proto__']:
       steps.append("(%s = %s.%s)" % (temp, prefix, accessor));
       prefix = temp
     return "%s && (%s = {prototype: %s})" % (' && '.join(steps), temp, temp)
 
+  def AddConstant(self, constant):
+    pass
 
   def AddGetter(self, attr):
     """Emits code to initialize an attribute getter."""
     if attr.type.id in _evasive_types:
       self._proto_code.Emit('    $PROTOREF.$NAME$getter = function() {'
                             ' return DOM$fixValue$$TYPE(this.$NAME);'
                             ' };\n',
                             NAME=attr.id, TYPE=attr.type.id)
     else:
       self._proto_code.Emit('    $PROTOREF.$NAME$getter = function() {'
@@ skipping 100 matching lines @@
     if interface.parents:
       supertype = interface.parents[0].type.id
       # FIXME: We're currently injecting List<..> and EventTarget as
       # supertypes in dart.idl. We should annotate/preserve as
       # attributes instead.  For now, this hack lets the interfaces
       # inherit, but not the classes.
       if (not _IsDartListType(supertype) and
           not supertype == 'EventTarget'):
         base = self._ImplClassName(supertype)
       if _IsDartCollectionType(supertype):
-        # List methods are injected in AddListImplementation.
+        # List methods are injected in AddIndexer.
         pass
       elif supertype == 'EventTarget':
         # Most implementors of EventTarget specify the EventListener operations
         # again.  If the operations are not specified, try to inherit from the
         # EventTarget implementation.
         #
         # Applies to MessagePort.
         if not [op for op in interface.operations if op.id == 'addEventListener']:
           base = self._ImplClassName(supertype)
       else:
@@ skipping 52 matching lines @@
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
   def _SecondaryContext(self, interface):
     if interface is not self._current_secondary_parent:
       self._current_secondary_parent = interface
       self._members_emitter.Emit('\n  // From $WHERE\n', WHERE=interface.id)
 
-
-  def AddListImplementation(self, element_type):
+  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
     # 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> ...
     #
@@ skipping 15 matching lines @@
     Arguments:
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($ARGS) native;\n',
         TYPE=info.type_name,
         NAME=info.name,
         ARGS=info.arg_implementation_declaration)