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
 import systemwrapping
 from generator import *
 from systembase import *
+from idlnode import IDLOperation
 
 class NativeImplementationSystem(System):
 
   def __init__(self, templates, database, emitters, auxiliary_dir, output_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
 
     self._auxiliary_dir = auxiliary_dir
     self._dom_public_files = []
     self._dom_impl_files = []
@@ skipping 532 matching lines @@
   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):

[sra1, 2012/05/03 19:12:35]

I think in many cases we will want to handle statics specially.  Statics also
don't inherit from interfaces/

Lets split the entry, AddOperation and AddStaticOperation and distinguish in the
driver.

You native version of AddStaticOperation is free to call AddOperation as an
implementation detail, or both call a common _AddOperation
It may want to do something extra, like make the global definition call the
implementation class static.

[Anton Muhin, 2012/05/04 11:05:13]

Done.

     """
     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)
@@ skipping 23 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.
-    for (i, argument) in enumerate(operation.arguments):
-      if (i == len(operation.arguments) - 1 and
+    start_index = 1
+    if operation.is_static:
+      start_index = 0
+    for (i, argument) in enumerate(operation.arguments, start_index):
+      if (i - start_index == 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
       self._GenerateParameterAdapter(parameter_definitions_emitter, argument, i)

[podivilov, 2012/05/03 09:05:42]

Please add start_index here and let i be the index in operation.arguments.

       arguments.append(argument.id)
 
     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 41 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 or idl_node.id,
-        INDEX=index + 1,
+        INDEX=index,
         FLAGS=flags)
 
   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'
         '  $DART_DECLARATION native "$NATIVE_BINDING";\n',
         DART_DECLARATION=dart_declaration, NATIVE_BINDING=native_binding)
 
@@ skipping 22 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 isinstance(idl_node, IDLOperation) and idl_node.is_static:

[podivilov, 2012/05/03 09:05:42]

I doubt that static attributes will be accessible on WebCore instances. This
isinstance check seems unnecessary. Please remove it.

+      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