Introduce TypeRegistry class.

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)
+  def __init__(self, options, auxiliary_dir):
+    super(NativeImplementationSystem, self).__init__(options)
     self._auxiliary_dir = auxiliary_dir
     self._cpp_header_files = []
     self._cpp_impl_files = []
-    self._html_system = HtmlSystemShared(database)
+    self._html_system = HtmlSystemShared(self._database)
 
   def ImplementationGenerator(self, interface):
     return NativeImplementationGenerator(self, interface)
 
   def ProcessCallback(self, interface, info):
     self._interface = interface
 
     if IsPureInterface(self._interface.id):
       return None
 
     cpp_impl_includes = set()
     cpp_header_handlers_emitter = emitter.Emitter()
     cpp_impl_handlers_emitter = emitter.Emitter()
     class_name = 'Dart%s' % self._interface.id
     for operation in interface.operations:
       if operation.type.id == 'void':
         return_prefix = ''
         error_return = ''
       else:
         return_prefix = 'return '
         error_return = ' false'
 
       parameters = []
       arguments = []
       for argument in operation.arguments:
-        argument_type_info = GetIDLTypeInfo(argument.type.id)
+        argument_type_info = self._type_registry.TypeInfo(argument.type.id)
         parameters.append('%s %s' % (argument_type_info.parameter_type(),
                                      argument.id))
         arguments.append(argument_type_info.to_dart_conversion(argument.id))
         cpp_impl_includes |= set(argument_type_info.conversion_includes())
 
-      native_return_type = GetIDLTypeInfo(operation.type.id).native_type()
+      native_return_type = self._type_registry.TypeInfo(operation.type.id).native_type()
       cpp_header_handlers_emitter.Emit(
           '\n'
           '    virtual $TYPE handleEvent($PARAMETERS);\n',
           TYPE=native_return_type, PARAMETERS=', '.join(parameters))
 
       arguments_declaration = 'Dart_Handle arguments[] = { %s }' % ', '.join(arguments)
       if not len(arguments):
         arguments_declaration = 'Dart_Handle* arguments = 0'
       cpp_impl_handlers_emitter.Emit(
           '\n'
@@ skipping 138 matching lines @@
       cpp_header_path = self._system._FilePathForCppHeader(self._interface.id)
       self._system._cpp_header_files.append(cpp_header_path)
       self._cpp_header_emitter = self._system._emitters.FileEmitter(cpp_header_path)
       cpp_impl_path = self._system._FilePathForCppImplementation(self._interface.id)
       self._system._cpp_impl_files.append(cpp_impl_path)
       self._cpp_impl_emitter = self._system._emitters.FileEmitter(cpp_impl_path)
     else:
       self._cpp_header_emitter = emitter.Emitter()
       self._cpp_impl_emitter = emitter.Emitter()
 
-    self._interface_type_info = GetIDLTypeInfo(self._interface.id)
+    self._interface_type_info = self._TypeInfo(self._interface.id)
     self._members_emitter = emitter.Emitter()
     self._cpp_declarations_emitter = emitter.Emitter()
     self._cpp_impl_includes = set()
     self._cpp_definitions_emitter = emitter.Emitter()
     self._cpp_resolver_emitter = emitter.Emitter()
 
     self._GenerateConstructors()
     return self._members_emitter
 
   def _GenerateConstructors(self):
@@ skipping 254 matching lines @@
   def AddAttribute(self, attribute, html_name, read_only):
     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)
+    type_info = self._TypeInfo(attr.type.id)
     dart_declaration = '%s get %s()' % (self._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
 
     if 'Reflect' in attr.ext_attrs:
-      webcore_function_name = GetIDLTypeInfo(attr.type.id).webcore_getter_name()
+      webcore_function_name = self._TypeInfo(attr.type.id).webcore_getter_name()
       if 'URL' in attr.ext_attrs:
         if 'NonEmpty' in attr.ext_attrs:
           webcore_function_name = 'getNonEmptyURLAttribute'
         else:
           webcore_function_name = 'getURLAttribute'
       arguments.append(self._GenerateWebCoreReflectionAttributeName(attr))
     else:
       if attr.id == 'operator':
         webcore_function_name = '_operator'
       elif attr.id == 'target' and attr.type.id == 'SVGAnimatedString':
         webcore_function_name = 'svgTarget'
       else:
         webcore_function_name = _ToWebKitName(attr.id)
       if attr.type.id.startswith('SVGAnimated'):
         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)
+    type_info = self._TypeInfo(attr.type.id)
     dart_declaration = 'void set %s(%s)' % (html_name, self._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)
 
     if 'Reflect' in attr.ext_attrs:
-      webcore_function_name = GetIDLTypeInfo(attr.type.id).webcore_setter_name()
+      webcore_function_name = self._TypeInfo(attr.type.id).webcore_setter_name()
       arguments.append(self._GenerateWebCoreReflectionAttributeName(attr))
     else:
       webcore_function_name = re.sub(r'^(xml(?=[A-Z])|\w)',
                                      lambda s: s.group(1).upper(),
                                      attr.id)
       webcore_function_name = 'set%s' % webcore_function_name
       if attr.type.id.startswith('SVGAnimated'):
         webcore_function_name += 'Animated'
 
     argument_expression = self._GenerateToNative(
@@ skipping 303 matching lines @@
         '{\n'
         '    DartApiScope dartApiScope;\n'
         '$BODY'
         '}\n',
         CALLBACK_NAME=callback_name,
         BODY=body)
 
   def _GenerateToNative(self, emitter, idl_node, index,
                                 argument_name=None):
     """idl_node is IDLArgument or IDLAttribute."""
-    type_info = GetIDLTypeInfo(idl_node.type.id)
+    type_info = self._TypeInfo(idl_node.type.id)
     self._cpp_impl_includes |= set(type_info.to_native_includes())
     argument_name = argument_name or idl_node.id
     handle = 'Dart_GetNativeArgument(args, %i)' % index
     return type_info.emit_to_native(emitter, idl_node, argument_name, handle, self._interface.id)
 
   def _GenerateNativeBinding(self, idl_name, argument_count, dart_declaration,
       native_suffix, is_custom):
     native_binding = '%s_%s_%s' % (self._interface.id, idl_name, native_suffix)
     self._members_emitter.Emit(
         '\n'
@@ skipping 33 matching lines @@
     if 'ImplementedBy' in idl_node.ext_attrs:
       return '%s::%s' % (idl_node.ext_attrs['ImplementedBy'], function_name)
     if idl_node.is_static:
       return '%s::%s' % (self._interface_type_info.idl_type(), function_name)
     return '%s%s' % (self._interface_type_info.receiver(), function_name)
 
   def _GenerateWebCoreInvocation(self, function_expression, arguments,
       idl_return_type, attributes, raises_dom_exceptions):
     invocation_template = '        $FUNCTION_CALL;\n'
     if idl_return_type != 'void':
-      return_type_info = GetIDLTypeInfo(idl_return_type)
+      return_type_info = self._TypeInfo(idl_return_type)
       self._cpp_impl_includes |= set(return_type_info.conversion_includes())
 
       # Generate to Dart conversion of C++ value.
       to_dart_conversion = return_type_info.to_dart_conversion('$FUNCTION_CALL', self._interface.id, attributes)
       invocation_template = emitter.Format(
           '        Dart_Handle returnValue = $TO_DART_CONVERSION;\n'
           '        if (returnValue)\n'
           '            Dart_SetReturnValue(args, returnValue);\n',
           TO_DART_CONVERSION=to_dart_conversion)
 
     if raises_dom_exceptions:
       # Add 'ec' argument to WebCore invocation and convert DOM exception to Dart exception.
       arguments.append('ec')
       invocation_template = emitter.Format(
           '        ExceptionCode ec = 0;\n'
           '$INVOCATION'
           '        if (UNLIKELY(ec)) {\n'
           '            exception = DartDOMWrapper::exceptionCodeToDartException(ec);\n'
           '            goto fail;\n'
           '        }\n',
           INVOCATION=invocation_template)
 
     if 'ImplementedBy' in attributes:
       arguments.insert(0, 'receiver')
       self._cpp_impl_includes.add('"%s.h"' % attributes['ImplementedBy'])
 
     return emitter.Format(invocation_template,
         FUNCTION_CALL='%s(%s)' % (function_expression, ', '.join(arguments)))
 
+  def _TypeInfo(self, type_name):
+    return self._system._type_registry.TypeInfo(type_name)
+
 
 def _GenerateCPPIncludes(includes):
   return ''.join(['#include %s\n' % include for include in sorted(includes)])
 
 def _FindInHierarchy(database, interface, test):
   if test(interface):
     return interface
   for parent in interface.parents:
     parent_name = parent.type.id
     if not database.HasInterface(parent.type.id):
       continue
     parent_interface = database.GetInterface(parent.type.id)
     parent_interface = _FindInHierarchy(database, parent_interface, test)
     if parent_interface:
       return parent_interface
 
 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)