Stop passing HtmlSystemShared around and move html renaming to IDLTypeInfo.

lib/dom/scripts/systemnative.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 systems to generate
 native binding from the IDL database."""
 
 import emitter
 import os
 import systembase
 from generator import *
-from systemhtml import HtmlSystemShared
 
 
 class NativeImplementationSystem(systembase.System):
 
   def __init__(self, templates, database, emitters, output_dir, auxiliary_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._auxiliary_dir = auxiliary_dir
     self._cpp_header_files = []
     self._cpp_impl_files = []
-    self._html_system = HtmlSystemShared(database)
 
   def ImplementationGenerator(self, interface):
     return NativeImplementationGenerator(self, interface)
 
   def ProcessCallback(self, interface, info):
     self._interface = interface
 
     if IsPureInterface(self._interface.id):
       return None
 
@@ skipping 126 matching lines @@
     Args:
       system: The NativeImplementationSystem.
       interface: an IDLInterface instance. It is assumed that all types have
           been converted to Dart types (e.g. int, String), unless they are in
           the same package as the interface.
     """
     super(NativeImplementationGenerator, self).__init__(
         system._database, interface)
     self._system = system
     self._current_secondary_parent = None
-    self._html_system = self._system._html_system
-    self._html_interface_name = self._html_system._html_renames.get(
-        self._interface.id, self._interface.id)
+    self._html_interface_name = DartInterfaceName(self._interface)
 
   def HasImplementation(self):
     return not IsPureInterface(self._interface.id)
 
   def ImplementationClassName(self):
     return self._ImplClassName(self._interface.id)
 
   def FilePathForDartImplementation(self):
     return os.path.join(self._system._output_dir, 'dart',
                         '%sImplementation.dart' % self._interface.id)
@@ skipping 130 matching lines @@
 
     self._GenerateNativeCallback(callback_name='constructorCallback',
         parameter_definitions=parameter_definitions_emitter.Fragments(),
         needs_receiver=False, invocation=invocation,
         raises_exceptions=raises_exceptions,
         runtime_check=runtime_check)
 
   def _ImplClassName(self, interface_name):
     return '_%sImpl' % interface_name
 
-  def _DartType(self, idl_type):
-    return self._html_system.DartType(idl_type)
-
   def _BaseClassName(self):
     root_class = 'NativeFieldWrapperClass1'
 
     if not self._interface.parents:
       return root_class
 
     supertype = self._interface.parents[0].type.id
 
     if IsPureInterface(supertype):    # The class is a root.
       return root_class
@@ skipping 16 matching lines @@
     template_file = 'factoryprovider_%s.darttemplate' % self._html_interface_name
     template = self._system._templates.TryLoad(template_file)
     if not template:
       template = self._system._templates.Load('factoryprovider.darttemplate')
 
     native_binding = '%s_constructor_Callback' % self._interface.id
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         INTERFACE=self._html_interface_name,
-        PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
+        PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
         ARGUMENTS=constructor_info.ParametersAsArgumentList(),
         NATIVE_NAME=native_binding)
 
   def FinishInterface(self):
     template = None
     if self._html_interface_name == self._interface.id or not self._database.HasInterface(self._html_interface_name):
       template_file = 'impl_%s.darttemplate' % self._html_interface_name
       template = self._system._templates.TryLoad(template_file)
     if not template:
       template = self._system._templates.Load('dart_implementation.darttemplate')
@@ skipping 99 matching lines @@
     if 'CheckSecurityForNode' in attribute.ext_attrs:
       # FIXME: exclude from interface as well.
       return
 
     self._AddGetter(attribute, html_name)
     if not read_only:
       self._AddSetter(attribute, html_name)
 
   def _AddGetter(self, attr, html_name):
     type_info = GetIDLTypeInfo(attr.type.id)
-    dart_declaration = '%s get %s()' % (self._DartType(attr.type.id), html_name)
+    dart_declaration = '%s get %s()' % (DartType(attr.type.id), html_name)
     is_custom = 'Custom' in attr.ext_attrs or 'CustomGetter' in attr.ext_attrs
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 1,
         dart_declaration, 'Getter', is_custom)
     if is_custom:
       return
 
     arguments = []
     parameter_definitions_emitter = emitter.Emitter()
     raises_exceptions = self._GenerateCallWithHandling(attr, parameter_definitions_emitter, arguments)
     raises_exceptions = raises_exceptions or attr.get_raises
@@ skipping 17 matching lines @@
         webcore_function_name += 'Animated'
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     invocation = self._GenerateWebCoreInvocation(function_expression,
         arguments, attr.type.id, attr.ext_attrs, attr.get_raises)
     self._GenerateNativeCallback(cpp_callback_name, parameter_definitions_emitter.Fragments(),
         True, invocation, raises_exceptions=raises_exceptions)
 
   def _AddSetter(self, attr, html_name):
     type_info = GetIDLTypeInfo(attr.type.id)
-    dart_declaration = 'void set %s(%s)' % (html_name, self._DartType(attr.type.id))
+    dart_declaration = 'void set %s(%s)' % (html_name, DartType(attr.type.id))
     is_custom = set(['Custom', 'CustomSetter', 'V8CustomSetter']) & set(attr.ext_attrs)
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 2,
         dart_declaration, 'Setter', is_custom)
     if is_custom:
       return
 
     arguments = []
     parameter_definitions_emitter = emitter.Emitter()
     self._GenerateCallWithHandling(attr, parameter_definitions_emitter, arguments)
 
@@ skipping 32 matching lines @@
     #   interface Y extends X, List<T> ...
     #
     # In the non-root case we have to choose between:
     #
     #   class YImpl extends XImpl { add List<T> methods; }
     #
     # and
     #
     #   class YImpl extends ListBase<T> { copies of transitive XImpl methods; }
     #
-    dart_element_type = self._DartType(element_type)
+    dart_element_type = DartType(element_type)
     if self._HasNativeIndexGetter():
       self._EmitNativeIndexGetter(dart_element_type)
     else:
       self._members_emitter.Emit(
           '\n'
           '  $TYPE operator[](int index) native "$(INTERFACE)_item_Callback";\n',
           TYPE=dart_element_type, INTERFACE=self._interface.id)
 
     if self._HasNativeIndexSetter():
       self._EmitNativeIndexSetter(dart_element_type)
@@ skipping 20 matching lines @@
     self._members_emitter.Emit(template, E=dart_element_type)
 
   def AmendIndexer(self, element_type):
     # If interface is marked as having native indexed
     # getter or setter, we must emit overrides as it's not
     # guaranteed that the corresponding methods in C++ would be
     # virtual.  For example, as of time of writing, even though
     # Uint8ClampedArray inherits from Uint8Array, ::set method
     # is not virtual and accessing it through Uint8Array pointer
     # would lead to wrong semantics (modulo vs. clamping.)
-    dart_element_type = self._DartType(element_type)
+    dart_element_type = DartType(element_type)
 
     if self._HasNativeIndexGetter():
       self._EmitNativeIndexGetter(dart_element_type)
     if self._HasNativeIndexSetter():
       self._EmitNativeIndexSetter(dart_element_type)
 
   def _HasNativeIndexGetter(self):
     ext_attrs = self._interface.ext_attrs
     return ('CustomIndexedGetter' in ext_attrs or
         'NumericIndexedGetter' in ext_attrs)
 
   def _EmitNativeIndexGetter(self, element_type):
     dart_declaration = '%s operator[](int index)' % element_type
     self._GenerateNativeBinding('numericIndexGetter', 2, dart_declaration,
         'Callback', True)
 
   def _HasNativeIndexSetter(self):
     return 'CustomIndexedSetter' in self._interface.ext_attrs
 
   def _EmitNativeIndexSetter(self, element_type):
     dart_declaration = 'void operator[]=(int index, %s value)' % element_type
     self._GenerateNativeBinding('numericIndexSetter', 3, dart_declaration,
         'Callback', True)
 
-  def _AddOperation(self, info):
+  def AddOperation(self, info, html_name):
     """
     Arguments:
       info: An OperationInfo object.
     """
 
     operation = info.operations[0]
 
     if 'CheckSecurityForNode' in operation.ext_attrs:
       # FIXME: exclude from interface as well.
       return
 
-    html_name = self._html_system.RenameInHtmlLibrary(
-        self._interface.id, info.name, implementation_class=True)
-
-    if not html_name and info.name == 'item':
-      # FIXME: item should be renamed to operator[], not removed.
-      html_name = '_item'
-
-    if not html_name:
-      return
-
     is_custom = 'Custom' in operation.ext_attrs
     has_optional_arguments = any(_IsArgumentOptionalInWebCore(argument) for argument in operation.arguments)
     needs_dispatcher = not is_custom and (len(info.operations) > 1 or has_optional_arguments)
 
     if not needs_dispatcher:
-      type_renamer = self._DartType
+      type_renamer = DartType
       default_value = 'null'
     else:
       type_renamer = lambda x: 'Dynamic'
       default_value = '_null'
 
     dart_declaration = '%s%s %s(%s)' % (
         'static ' if info.IsStatic() else '',
-        self._DartType(info.type_name),
+        DartType(info.type_name),
         html_name,
         info.ParametersImplementationDeclaration(type_renamer, default_value))
 
     if not needs_dispatcher:
       # Bind directly to native implementation
       argument_count = (0 if info.IsStatic() else 1) + len(info.param_infos)
       cpp_callback_name = self._GenerateNativeBinding(
           info.name, argument_count, dart_declaration, 'Callback', is_custom)
       if not is_custom:
         self._GenerateOperationNativeCallback(operation, operation.arguments, cpp_callback_name)
@@ skipping 23 matching lines @@
           template = '    $CALL;\n'
 
       overload_name = '%s_%s' % (operation.id, version[0])
       version[0] += 1
       argument_list = ', '.join(argument_names[:argument_count])
       call = '_%s(%s)' % (overload_name, argument_list)
       body.Emit(template, CHECKS=' && '.join(checks), CALL=call)
 
       dart_declaration = '%s%s _%s(%s)' % (
           'static ' if operation.is_static else '',
-          self._DartType(operation.type.id), overload_name, argument_list)
+          DartType(operation.type.id), overload_name, argument_list)
       cpp_callback_name = self._GenerateNativeBinding(
           overload_name, (0 if operation.is_static else 1) + argument_count,
           dart_declaration, 'Callback', False)
       self._GenerateOperationNativeCallback(operation, operation.arguments[:argument_count], cpp_callback_name)
 
     def GenerateChecksAndCall(operation, argument_count):
       checks = ['%s === _null' % name for name in argument_names]
       for i in range(0, argument_count):
         argument = operation.arguments[i]
         argument_name = argument_names[i]
         checks[i] = '(%s is %s || %s === null)' % (
-            argument_name, self._DartType(argument.type.id), argument_name)
+            argument_name, DartType(argument.type.id), argument_name)
       GenerateCall(operation, argument_count, checks)
 
     # TODO: Optimize the dispatch to avoid repeated checks.
     if len(operations) > 1:
       for operation in operations:
         for position, argument in enumerate(operation.arguments):
           if _IsArgumentOptionalInWebCore(argument):
             GenerateChecksAndCall(operation, position)
         GenerateChecksAndCall(operation, len(operation.arguments))
       body.Emit('    throw "Incorrect number or type of arguments";\n');
     else:
       operation = operations[0]
       for position, argument in list(enumerate(operation.arguments))[::-1]:
         if _IsArgumentOptionalInWebCore(argument):
           check = '%s === _null' % argument_names[position]
           GenerateCall(operation, position, [check])
       GenerateCall(operation, len(operation.arguments), [])
 
-  def AddOperation(self, info):
-    self._AddOperation(info)
-
-  def AddStaticOperation(self, info):
-    self._AddOperation(info)
-
   def SecondaryContext(self, interface):
     pass
 
   def _GenerateOperationNativeCallback(self, operation, arguments, cpp_callback_name):
     webcore_function_name = operation.ext_attrs.get('ImplementedAs', operation.id)
 
     parameter_definitions_emitter = emitter.Emitter()
     cpp_arguments = []
     raises_exceptions = self._GenerateCallWithHandling(
         operation, parameter_definitions_emitter, cpp_arguments)
@@ skipping 203 matching lines @@
 
 def _IsArgumentOptionalInWebCore(argument):
   return IsOptional(argument) and not 'Callback' in argument.ext_attrs
 
 def _ToWebKitName(name):
   name = name[0].lower() + name[1:]
   name = re.sub(r'^(hTML|uRL|jS|xML|xSLT)', lambda s: s.group(1).lower(),
                 name)
   return re.sub(r'^(create|exclusive)', lambda s: 'is' + s.group(1).capitalize(),
                 name)