Rework static method support.

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
@@ skipping 286 matching lines @@
             '            exception = Dart_NewString("Failed to create an object");\n'
             '            goto fail;\n'
             '        }\n')
         arguments.append('context')
       else:
         raise Exception('Unsupported CallWith=%s attribute' % call_with)
 
     # Process constructor arguments.
     for (i, argument) in enumerate(constructor_info.idl_args):
       argument_expression = self._GenerateParameterAdapter(
-          parameter_definitions_emitter, argument, i - 1)
+          parameter_definitions_emitter, argument, i)
       arguments.append(argument_expression)
 
     function_expression = '%s::%s' % (self._interface_type_info.native_type(), create_function)
     invocation = self._GenerateWebCoreInvocation(function_expression, arguments,
         self._interface.id, self._interface.ext_attrs, raises_dom_exceptions)
     self._GenerateNativeCallback(callback_name='constructorCallback',
         parameter_definitions=parameter_definitions_emitter.Fragments(),
         needs_receiver=False, invocation=invocation,
         raises_exceptions=raises_exceptions)
 
@@ skipping 213 matching lines @@
       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._GenerateParameterAdapter(
-        parameter_definitions_emitter, attr, 0, adapter_name='value')
+        parameter_definitions_emitter, attr, 1, adapter_name='value')
     arguments.append(argument_expression)
 
     parameter_definitions = parameter_definitions_emitter.Fragments()
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     invocation = self._GenerateWebCoreInvocation(function_expression,
         arguments, 'void', attr.ext_attrs, attr.set_raises)
 
     self._GenerateNativeCallback(cpp_callback_name, parameter_definitions_emitter.Fragments(),
         True, invocation, raises_exceptions=True)
 
   def _HasNativeIndexGetter(self, interface):
     return ('CustomIndexedGetter' in interface.ext_attrs or
             'NumericIndexedGetter' in interface.ext_attrs)
 
   def _EmitNativeIndexGetter(self, interface, element_type):
     dart_declaration = '%s operator[](int index)' % element_type
     self._GenerateNativeBinding('numericIndexGetter', 2, dart_declaration,
         'Callback', True)
 
   def _EmitNativeIndexSetter(self, interface, 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):
     """
     Arguments:
       info: An OperationInfo object.
     """
 
     if 'CheckSecurityForNode' in info.overloads[0].ext_attrs:
       # FIXME: exclude from interface as well.
       return
 
     if 'Custom' in info.overloads[0].ext_attrs:
       parameters = info.ParametersImplementationDeclaration()
       dart_declaration = '%s %s(%s)' % (info.type_name, info.name, parameters)
       argument_count = 1 + len(info.param_infos)
       self._GenerateNativeBinding(info.name, argument_count, dart_declaration,
           'Callback', True)
       return
 
+    modifier = ''
+    if info.IsStatic():
+      modifier = 'static '
     body = self._members_emitter.Emit(
         '\n'
-        '  $TYPE $NAME($PARAMETERS) {\n'
+        '  $MODIFIER$TYPE $NAME($PARAMETERS) {\n'
         '$!BODY'
         '  }\n',
+        MODIFIER=modifier,
         TYPE=info.type_name,
         NAME=info.name,
         PARAMETERS=info.ParametersImplementationDeclaration())
 
     # Process in order of ascending number of arguments to ensure missing
     # optional arguments are processed early.
     overloads = sorted(info.overloads,
                        key=lambda overload: len(overload.arguments))
     self._native_version = 0
     fallthrough = self.GenerateDispatch(body, info, '    ', 0, overloads)
     if fallthrough:
       body.Emit('    throw "Incorrect number or type of arguments";\n');
 
+  def AddOperation(self, info):
+    self._AddOperation(info)
+
+  def AddStaticOperation(self, info):
+    self._AddOperation(info)
+
   def GenerateSingleOperation(self,  dispatch_emitter, info, indent, operation):
     """Generates a call to a single operation.
 
     Arguments:
       dispatch_emitter: an dispatch_emitter for the body of a block of code.
       info: the compound information about the operation and its overloads.
       indent: an indentation string for generated code.
       operation: the IDLOperation to call.
     """
 
@@ skipping 10 matching lines @@
                             INDENT=indent,
                             NATIVENAME=native_name,
                             ARGS=argument_list)
     else:
       dispatch_emitter.Emit('$(INDENT)_$NATIVENAME($ARGS);\n'
                             '$(INDENT)return;\n',
                             INDENT=indent,
                             NATIVENAME=native_name,
                             ARGS=argument_list)
     # Generate binding.
-    dart_declaration = '%s _%s(%s)' % (info.type_name, native_name,
+    modifier = ''
+    if operation.is_static:
+      modifier = 'static '
+    dart_declaration = '%s%s _%s(%s)' % (modifier, info.type_name, native_name,
                                        argument_list)
     is_custom = 'Custom' in operation.ext_attrs
     cpp_callback_name = self._GenerateNativeBinding(
         native_name, 1 + len(operation.arguments), dart_declaration, 'Callback',
         is_custom)
     if is_custom:
       return
 
     # Generate callback.
     webcore_function_name = operation.ext_attrs.get('ImplementedAs', operation.id)
 
     parameter_definitions_emitter = emitter.Emitter()
     arguments = []
     raises_exceptions = self._GenerateCallWithHandling(
         operation, parameter_definitions_emitter, arguments)
     raises_exceptions = raises_exceptions or len(operation.arguments) > 0 or operation.raises
 
     # Process Dart arguments.
+    start_index = 1
+    if operation.is_static:
+      start_index = 0
     for (i, argument) in enumerate(operation.arguments):
       if (i == len(operation.arguments) - 1 and
           self._interface.id == 'Console' and
           argument.id == 'arg'):
         # FIXME: we are skipping last argument here because it was added in
         # supplemental dart.idl. Cleanup dart.idl and remove this check.
         break
       argument_expression = self._GenerateParameterAdapter(
-          parameter_definitions_emitter, argument, i)
+          parameter_definitions_emitter, argument, start_index + i)
       arguments.append(argument_expression)
 
     if operation.id in ['addEventListener', 'removeEventListener']:
       # addEventListener's and removeEventListener's last argument is marked
       # as optional in idl, but is not optional in webcore implementation.
       if len(operation.arguments) == 2:
         arguments.append('false')
 
     if self._interface.id == 'CSSStyleDeclaration' and operation.id == 'setProperty':
       # CSSStyleDeclaration.setProperty priority parameter is optional in Dart
       # idl, but is not optional in webcore implementation.
       if len(operation.arguments) == 2:
         arguments.append('String()')
 
     if 'NeedsUserGestureCheck' in operation.ext_attrs:
       arguments.append('DartUtilities::processingUserGesture')
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, operation)
     invocation = self._GenerateWebCoreInvocation(function_expression, arguments,
         operation.type.id, operation.ext_attrs, operation.raises)
     self._GenerateNativeCallback(cpp_callback_name,
         parameter_definitions=parameter_definitions_emitter.Fragments(),
-        needs_receiver=True, invocation=invocation,
+        needs_receiver=not operation.is_static, invocation=invocation,
         raises_exceptions=raises_exceptions)
 
   def _GenerateNativeCallback(self, callback_name, parameter_definitions,
       needs_receiver, invocation, raises_exceptions):
 
     if needs_receiver:
       parameter_definitions = emitter.Format(
           '        $WEBCORE_CLASS_NAME* receiver = DartDOMWrapper::receiver< $WEBCORE_CLASS_NAME >(args);\n'
           '        $PARAMETER_DEFINITIONS\n',
           WEBCORE_CLASS_NAME=self._interface_type_info.native_type(),
@@ skipping 42 matching lines @@
       flags = ', DartUtilities::ConvertNullToDefaultValue'
     emitter.Emit(
         '\n'
         '        const $ADAPTER_TYPE $NAME(Dart_GetNativeArgument(args, $INDEX)$FLAGS);\n'
         '        if (!$NAME.conversionSuccessful()) {\n'
         '            exception = $NAME.exception();\n'
         '            goto fail;\n'
         '        }\n',
         ADAPTER_TYPE=adapter_type,
         NAME=adapter_name,
-        INDEX=index + 1,
+        INDEX=index,
         FLAGS=flags)
 
     conversion = '%s'
     if isinstance(type_info, SVGTearOffIDLTypeInfo) and not self._interface.id.endswith('List'):
       conversion = '%s.get()->propertyReference()'
     elif type_info.idl_type() == 'SVGMatrix' and self._interface.id == 'SVGTransformList':
       conversion = '%s.get()'
     return conversion % adapter_name
 
   def _GenerateNativeBinding(self, idl_name, argument_count, dart_declaration,
@@ skipping 29 matching lines @@
     if self._interface.id.startswith('SVG') and not attr.id in svg_exceptions:
       namespace = 'SVGNames'
     self._cpp_impl_includes.add('"%s.h"' % namespace)
 
     attribute_name = attr.ext_attrs['Reflect'] or attr.id.lower()
     return 'WebCore::%s::%sAttr' % (namespace, attribute_name)
 
   def _GenerateWebCoreFunctionExpression(self, function_name, idl_node):
     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)
       self._cpp_impl_includes |= set(return_type_info.conversion_includes())
 
       # Generate to Dart conversion of C++ value.
@@ skipping 40 matching lines @@
 def _InstanceOfNode(database, interface):
   if interface.id == 'Node':
     return True
   for parent in interface.parents:
     if not database.HasInterface(parent.type.id):
       continue
     parent_interface = database.GetInterface(parent.type.id)
     if _InstanceOfNode(database, parent_interface):
       return True
   return False