Arity indexing in dart:blink entry points

tools/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 566 matching lines @@
     if interface_name == self._interface.id or not self._database.HasInterface(interface_name):
       template_file = 'impl_%s.darttemplate' % interface_name
       template = self._template_loader.TryLoad(template_file)
     if not template:
       template = self._template_loader.Load('dart_implementation.darttemplate')
     return template
 
   def RootClassName(self):
     return 'NativeFieldWrapperClass2'
 
-  def DeriveNativeEntry(self, operation_id, native_suffix, type_ids, skip_types):
+  # This code matches up with the _generate_native_entry code in
+  # dart_utilities.py in the dartium repository.  Any changes to this
+  # should have matching changes on that end.
+  def DeriveNativeEntry(self, name, kind, count):
     interface_id = self._interface.id
     database = self._database
-    type_ids = map(lambda type_id : TypeIdToBlinkName(type_id, database),
-                   type_ids)
-    encoded_type_ids = map(EncodeType, type_ids)
-    if native_suffix:
-      operation_id = "%s_%s" % (operation_id, native_suffix)
-      interface_id = TypeIdToBlinkName(interface_id, database)
+    tag = ""
+    if kind == 'Getter':
+        tag = "%s_Getter" % name
+        blink_entry = tag
+    elif kind == 'Setter':
+        tag = "%s_Setter" % name
+        blink_entry = tag
+    elif kind == 'Constructor':
+        tag = "constructorCallback"
+        blink_entry = tag
+    elif kind == 'Method':
+        tag = "%s_Callback" % name
+        blink_entry = tag
 
-    def DeriveString(components, types, use_types):
-      if use_types:
-        components.extend(types)
-      full_name = "_".join(components)
-      return full_name
+    interface_id = TypeIdToBlinkName(interface_id, database)
 
     def mkPublic(s):
       if s.startswith("_") or s.startswith("$"):
         return "$" + s
       return s
 
-    dart_name = mkPublic(DeriveString([operation_id], encoded_type_ids, True))
-    resolver_string = DeriveString([interface_id, operation_id], type_ids,
-                                   not skip_types)
+    if count:
+      arity = str(count)
+      dart_name = mkPublic("_".join([tag, arity]))
+    else:
+      dart_name = mkPublic(tag)
+    resolver_string = "_".join([interface_id, tag])
+
     return (dart_name, resolver_string)
 
 
   def DeriveNativeName(self, name, suffix=""):
       fields = ['$' + name]
       if suffix != "":
           fields.append(suffix)
       return "_".join(fields)
 
   def DeriveQualifiedBlinkName(self, interface_name, name):
@@ skipping 75 matching lines @@
     if arguments is None:
         arguments = constructor_info.idl_args[0]
         argument_count = len(arguments)
     else:
         argument_count = len(arguments)
 
     typed_formals = constructor_info.ParametersAsArgumentList(argument_count)
     parameters = constructor_info.ParametersAsStringOfVariables(argument_count)
     interface_name =  self._interface_type_info.interface_name()
 
-    type_ids = [p.type.id for p in arguments[:argument_count]]
     dart_native_name, constructor_callback_id = \
-        self.DeriveNativeEntry(cpp_suffix, None, type_ids, is_custom)
+        self.DeriveNativeEntry(cpp_suffix, 'Constructor', argument_count)
     if constructor_callback_id in _cpp_resolver_string_map:
         constructor_callback_id = \
             _cpp_resolver_string_map[constructor_callback_id]
     if dart_native_name not in self._blink_entries:
       self._blink_entries.add(dart_native_name)
       self._native_class_emitter.Emit(
         '\n'
         '  static $FACTORY_METHOD_NAME($PARAMETERS) native "$ID";\n',
         FACTORY_METHOD_NAME=dart_native_name,
         PARAMETERS=parameters,
@@ skipping 279 matching lines @@
     parameters = []
     dart_declaration = '%s get %s' % (return_type, html_name)
     is_custom = _IsCustom(attr) and (_IsCustomValue(attr, None) or
                                      _IsCustomValue(attr, 'Getter'))
     # This seems to have been replaced with Custom=Getter (see above), but
     # check to be sure we don't see the old syntax
     assert(not ('CustomGetter' in attr.ext_attrs))
     native_suffix = 'Getter'
     auto_scope_setup = self._GenerateAutoSetupScope(attr.id, native_suffix)
     native_entry = \
-        self.DeriveNativeEntry(attr.id, native_suffix, [], True)
+        self.DeriveNativeEntry(attr.id, 'Getter', None)
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 1,
         dart_declaration, False, return_type, parameters,
         native_suffix, is_custom, auto_scope_setup, native_entry=native_entry)
     if is_custom:
       return
 
     if 'Reflect' in attr.ext_attrs:
       webcore_function_name = self._TypeInfo(attr.type.id).webcore_getter_name()
       if 'URL' in attr.ext_attrs:
         if 'NonEmpty' in attr.ext_attrs:
@@ skipping 34 matching lines @@
     dart_declaration = 'void set %s(%s value)' % (html_name, ptype)
     is_custom = _IsCustom(attr) and (_IsCustomValue(attr, None) or
                                      _IsCustomValue(attr, 'Setter'))
     # This seems to have been replaced with Custom=Setter (see above), but
     # check to be sure we don't see the old syntax
     assert(not ('CustomSetter' in attr.ext_attrs))
     assert(not ('V8CustomSetter' in attr.ext_attrs))
     native_suffix = 'Setter'
     auto_scope_setup = self._GenerateAutoSetupScope(attr.id, native_suffix)
     native_entry = \
-        self.DeriveNativeEntry(attr.id, native_suffix, [attr.type.id], True)
+        self.DeriveNativeEntry(attr.id, 'Setter', None)
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 2,
         dart_declaration, False, return_type, parameters,
         native_suffix, is_custom, auto_scope_setup, native_entry=native_entry)
     if is_custom:
       return
 
     if 'Reflect' in attr.ext_attrs:
       webcore_function_name = self._TypeInfo(attr.type.id).webcore_setter_name()
     else:
       if 'ImplementedAs' in attr.ext_attrs:
@@ skipping 42 matching lines @@
     dart_element_type = self._DartType(element_type)
     if self._HasNativeIndexGetter():
       self._EmitNativeIndexGetter(dart_element_type)
     elif self._HasExplicitIndexedGetter():
       self._EmitExplicitIndexedGetter(dart_element_type)
     else:
       is_custom = any((op.id == 'item' and _IsCustom(op)) for op in self._interface.operations)
       # First emit a toplevel function to do the native call
       # Calls to this are emitted elsewhere,
       dart_native_name, resolver_string = \
-          self.DeriveNativeEntry("item", "Callback", ["unsigned long"],
-                                 is_custom)
+          self.DeriveNativeEntry("item", 'Method', 1)
       if resolver_string in _cpp_resolver_string_map:
           resolver_string = \
               _cpp_resolver_string_map[resolver_string]
 
       # Emit the method which calls the toplevel function, along with
       # the [] operator.
       dart_qualified_name = \
           self.DeriveQualifiedBlinkName(self._interface.id,
                                         dart_native_name)
       self._members_emitter.Emit(
@@ skipping 85 matching lines @@
     formals = info.ParametersAsDeclaration(self._DartType)
     parameters = info.ParametersAsListOfVariables()
     dart_declaration = '%s%s %s(%s)' % (
         'static ' if info.IsStatic() else '',
         return_type,
         html_name,
         formals)
 
     operation = info.operations[0]
     is_custom = _IsCustom(operation)
-    has_optional_arguments = any(self._IsArgumentOptionalInWebCore(operation, argument) for argument in operation.arguments)
+    has_optional_arguments = any(IsOptional(argument) for argument in operation.arguments)
     needs_dispatcher = not is_custom and (len(info.operations) > 1 or has_optional_arguments)
 
     if info.callback_args:
       self._AddFutureifiedOperation(info, html_name)
     elif not needs_dispatcher:
       # Bind directly to native implementation
       argument_count = (0 if info.IsStatic() else 1) + len(info.param_infos)
       native_suffix = 'Callback'
       auto_scope_setup = self._GenerateAutoSetupScope(info.name, native_suffix)
-      type_ids = [argument.type.id
-                  for argument in operation.arguments[:len(info.param_infos)]]
       native_entry = \
-          self.DeriveNativeEntry(operation.id, native_suffix, type_ids,
-                                 is_custom)
+          self.DeriveNativeEntry(operation.id, 'Method', len(info.param_infos))
       cpp_callback_name = self._GenerateNativeBinding(
         info.name, argument_count, dart_declaration,
         info.IsStatic(), return_type, parameters,
         native_suffix, is_custom, auto_scope_setup,
         native_entry=native_entry)
       if not is_custom:
         self._GenerateOperationNativeCallback(operation, operation.arguments, cpp_callback_name, auto_scope_setup)
     else:
       self._GenerateDispatcher(info, info.operations, dart_declaration, html_name)
 
@@ skipping 10 matching lines @@
       is_custom = _IsCustom(operation)
       base_name = '_%s_%s' % (operation.id, version)
       static = True
       if not operation.is_static:
         actuals = ['this'] + actuals
         formals = ['mthis'] + formals
       actuals_s = ", ".join(actuals)
       formals_s = ", ".join(formals)
       dart_declaration = '%s(%s)' % (
         base_name, formals_s)
-      type_ids = [argument.type.id
-                  for argument in operation.arguments[:argument_count]]
       native_entry = \
-          self.DeriveNativeEntry(operation.id, native_suffix, type_ids,
-                                 is_custom)
+          self.DeriveNativeEntry(operation.id, 'Method', argument_count)
       overload_base_name = native_entry[0]
       overload_name = \
           self.DeriveQualifiedBlinkName(self._interface.id,
                                         overload_base_name)
       call_emitter.Emit('$NAME($ARGS)', NAME=overload_name, ARGS=actuals_s)
       auto_scope_setup = \
         self._GenerateAutoSetupScope(base_name, native_suffix)
       cpp_callback_name = self._GenerateNativeBinding(
         base_name, (0 if static else 1) + argument_count,
         dart_declaration, static, return_type, formals,
         native_suffix, is_custom, auto_scope_setup, emit_metadata=False,
         emit_to_native=True, native_entry=native_entry)
       if not is_custom:
         self._GenerateOperationNativeCallback(operation,
           operation.arguments[:argument_count], cpp_callback_name,
           auto_scope_setup)
 
 
     self._GenerateDispatcherBody(
         info,
         operations,
         dart_declaration,
         GenerateCall,
-        self._IsArgumentOptionalInWebCore)
+        IsOptional)
 
   def SecondaryContext(self, interface):
     pass
 
   def _GenerateOperationNativeCallback(self, operation, arguments, cpp_callback_name, auto_scope_setup=True):
     webcore_function_name = operation.ext_attrs.get('ImplementedAs', operation.id)
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, operation, cpp_callback_name)
     self._GenerateNativeCallback(
         cpp_callback_name,
@@ skipping 690 matching lines @@
 
 def _IsCustom(op_or_attr):
   assert(isinstance(op_or_attr, IDLMember))
   return 'Custom' in op_or_attr.ext_attrs or 'DartCustom' in op_or_attr.ext_attrs
 
 def _IsCustomValue(op_or_attr, value):
   if _IsCustom(op_or_attr):
     return op_or_attr.ext_attrs.get('Custom') == value \
            or op_or_attr.ext_attrs.get('DartCustom') == value
   return False