Fix dart to native dispatch.

lib/dom/scripts/generator.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 systems to generate
 Dart APIs from the IDL database."""
 
 import copy
 import re
@@ skipping 161 matching lines @@
   return GetIDLTypeInfo(idl_type_name).dart_type()
 
 
 class ParamInfo(object):
   """Holder for various information about a parameter of a Dart operation.
 
   Attributes:
     name: Name of parameter.
     type_id: Original type id.  None for merged types.
     dart_type: DartType of parameter.
-    default_value: String holding the expression.  None for mandatory parameter.
+    is_optional: Parameter optionality.
   """
-  def __init__(self, name, type_id, dart_type, default_value):
+  def __init__(self, name, type_id, dart_type, is_optional):
     self.name = name
     self.type_id = type_id
     self.dart_type = dart_type
-    self.default_value = default_value
+    self.is_optional = is_optional
 
   def __repr__(self):
-    content = 'name = %s, type_id = %s, dart_type = %s, default_value = %s' % (
-        self.name, self.type_id, self.dart_type, self.default_value)
+    content = 'name = %s, type_id = %s, dart_type = %s, is_optional = %s' % (
+        self.name, self.type_id, self.dart_type, self.is_optional)
     return '<ParamInfo(%s)>' % content
 
 
 # Given a list of overloaded arguments, render a dart argument.
 def _DartArg(args, interface, constructor=False):
   # Given a list of overloaded arguments, choose a suitable name.
   def OverloadedName(args):
     return '_OR_'.join(sorted(set(arg.id for arg in args)))
 
   # Given a list of overloaded arguments, choose a suitable type.
   def OverloadedType(args):
     type_ids = sorted(set(arg.type.id for arg in args))
     dart_types = sorted(set(DartType(arg.type.id) for arg in args))
     if len(dart_types) == 1:
       if len(type_ids) == 1:
         return (type_ids[0], dart_types[0])
       else:
         return (None, dart_types[0])
     else:
       return (None, TypeName(type_ids, interface))
 
-  def NeedsDefaultValue(argument):
+  def IsOptional(argument):
     if not argument:
       return True
     if 'Callback' in argument.ext_attrs:
       # Callbacks with 'Optional=XXX' are treated as optional arguments.
       return 'Optional' in argument.ext_attrs
     if constructor:
       # FIXME: Constructors with 'Optional=XXX' shouldn't be treated as
       # optional arguments.
       return 'Optional' in argument.ext_attrs
     return False
 
   filtered = filter(None, args)
-  needs_default_value = any(NeedsDefaultValue(arg) for arg in args)
+  is_optional = any(IsOptional(arg) for arg in args)
   (type_id, dart_type) = OverloadedType(filtered)
   name = OverloadedName(filtered)
-  if needs_default_value:
-    return ParamInfo(name, type_id, dart_type, 'null')
-  else:
-    return ParamInfo(name, type_id, dart_type, None)
+  return ParamInfo(name, type_id, dart_type, is_optional)
 
 def IsOptional(argument):
   return ('Optional' in argument.ext_attrs and
           argument.ext_attrs['Optional'] == None)
 
 def AnalyzeOperation(interface, operations):
   """Makes operation calling convention decision for a set of overloads.
 
   Returns: An OperationInfo object.
   """
@@ skipping 140 matching lines @@
     name: A string, the simple name of the operation.
     constructor_name: A string, the name of the constructor iff the constructor
        is named, e.g. 'fromList' in  Int8Array.fromList(list).
     type_name: A string, the name of the return type of the operation.
     param_infos: A list of ParamInfo.
   """
 
   def ParametersInterfaceDeclaration(self):
     """Returns a formatted string declaring the parameters for the interface."""
     return self._FormatParams(
-        self.param_infos, True,
+        self.param_infos, None,
         lambda param: TypeOrNothing(param.dart_type, param.type_id))
 
-  def ParametersImplementationDeclaration(self, rename_type=None):
+  def ParametersImplementationDeclaration(
+      self, rename_type=None, default_value='null'):

[Anton Muhin, 2012/06/06 14:23:18]

do you need default value for default_value?

[podivilov, 2012/06/06 15:11:56]

Yes, it is needed for frog generators.

     """Returns a formatted string declaring the parameters for the
     implementation.
 
     Args:
       rename_type: A function that allows the types to be renamed.
         The function is applied to the parameter's dart_type.
     """
     if rename_type:
       def renamer(param_info):
         return TypeOrNothing(rename_type(param_info.dart_type))
-      return self._FormatParams(self.param_infos, False, renamer)
+      return self._FormatParams(self.param_infos, default_value, renamer)
     else:
       def type_fn(param_info):
         if param_info.dart_type == 'Dynamic':
           if param_info.type_id:
             # It is more informative to use a comment IDL type.
             return '/*%s*/' % param_info.type_id
           else:
             return 'var'
         else:
           return param_info.dart_type
       return self._FormatParams(
-          self.param_infos, False,
+          self.param_infos, default_value,
           lambda param: TypeOrNothing(param.dart_type, param.type_id))
 
   def ParametersAsArgumentList(self):
     """Returns a string of the parameter names suitable for passing the
     parameters as arguments.
     """
     return ', '.join(map(lambda param_info: param_info.name, self.param_infos))
 
-  def _FormatParams(self, params, is_interface, type_fn):
+  def _FormatParams(self, params, default_value, type_fn):
     def FormatParam(param):
       """Returns a parameter declaration fragment for an ParamInfo."""
       type = type_fn(param)
-      if is_interface or param.default_value is None:
-        return '%s%s' % (type, param.name)
-      else:
-        return '%s%s = %s' % (type, param.name, param.default_value)
+      if param.is_optional and default_value:
+        return '%s%s = %s' % (type, param.name, default_value)
+      return '%s%s' % (type, param.name)
 
     required = []
     optional = []
     for param_info in params:
-      if param_info.default_value:
+      if param_info.is_optional:
         optional.append(param_info)
       else:
         if optional:
           raise Exception('Optional parameters cannot precede required ones: '
-                          + str(args))
+                          + str(params))
         required.append(param_info)
     argtexts = map(FormatParam, required)
     if optional:
       argtexts.append('[' + ', '.join(map(FormatParam, optional)) + ']')
     return ', '.join(argtexts)
 
   def IsStatic(self):
     is_static = self.overloads[0].is_static
     assert any([is_static == o.is_static for o in self.overloads])
     return is_static
@@ skipping 339 matching lines @@
     '"SVGAnimatedListPropertyTearOff.h"',
     '"SVGTransformListPropertyTearOff.h"',
     '"SVGPathSegListPropertyTearOff.h"',
 ]
 
 def GetIDLTypeInfo(idl_type_name):
   match = re.match(r'sequence<(\w+)>$', idl_type_name)
   if match:
     return SequenceIDLTypeInfo(idl_type_name, GetIDLTypeInfo(match.group(1)))
   return _idl_type_registry.get(idl_type_name, IDLTypeInfo(idl_type_name))