Removing interfaces from dart:html

lib/html/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 344 matching lines @@
     implementation.
 
     Args:
       rename_type: A function that allows the types to be renamed.
         The function is applied to the parameter's dart_type.
     """
     return self._FormatParams(
         self.param_infos, 'null',
         lambda param: TypeOrNothing(rename_type(param.dart_type)))
 
-  def ParametersAsArgumentList(self):
+  def ParametersAsArgumentList(self, parameter_count = None):
     """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))
+    if parameter_count is None:

[Anton Muhin, 2012/09/17 10:11:28]

please, do not duplicate common logic.  Instead, something like:
 if parameter_count is None:
  parameter_count = len(self.param_infos)

or even in the decl parameter_count = sys.maxint

[blois, 2012/09/17 19:48:22]

Done.

+      return ', '.join(map(lambda param_info: param_info.name, self.param_infos))
+    return ', '.join(map(
+        lambda param_info: param_info.name,
+        self.param_infos[:parameter_count]))
 
   def _FormatParams(self, params, default_value, type_fn):
     def FormatParam(param):
       """Returns a parameter declaration fragment for an ParamInfo."""
       type = type_fn(param)
       if param.is_optional and default_value and default_value != 'null':
         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.is_optional:
         optional.append(param_info)
       else:
         if optional:
           raise Exception('Optional parameters cannot precede required ones: '
                           + 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
 
   def ConstructorFullName(self):

[Anton Muhin, 2012/09/17 10:11:28]

with your change, are there any other references to this method?

[blois, 2012/09/17 19:48:22]

Only within this file, made it private.

     if self.constructor_name:
       return self.type_name + '.' + self.constructor_name
     else:
       return self.type_name
 
+  def ConstructorFactoryName(self, rename_type):
+    type_name = rename_type(self.type_name)

[Anton Muhin, 2012/09/17 10:11:28]

why you rename type here, but it's not renamed in ConstructorFullName above?

Overall cannot ConstructorFactoryName be something like: 'create' +
ConstructorFullName() ?

[blois, 2012/09/17 19:48:22]

The rename_type here converts between DOM names and Dart names
(WebKitCSSMatrix->CSSMatrix), this is handled from the callsites elsewhere.

I've converted this method to call ConstructorFullName and more closely follow
the others.

On 2012/09/17 10:11:28, Anton Muhin wrote:

+    if self.constructor_name:
+      return 'create' + type_name + '_' + self.constructor_name
+    else:
+      return 'create' + type_name
+
+  def GenerateFactoryInvocation(self, rename_type, emitter, factory_provider):
+    has_optional = False

[Anton Muhin, 2012/09/17 10:11:28]

has_optional = any(param_info.is_optional for param_info in self.param_infos) ?

[blois, 2012/09/17 19:48:22]

Done.

+    for param_info in self.param_infos:
+      if param_info.is_optional:
+        has_optional = True
+
+    factory_name = self.ConstructorFactoryName(rename_type)
+    if not has_optional:
+      emitter.Emit(
+          '\n'
+          '  factory $CTOR($PARAMS) => $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
+          CTOR=rename_type(self.ConstructorFullName()),
+          PARAMS=self.ParametersInterfaceDeclaration(rename_type),
+          FACTORY=factory_provider,
+          CTOR_FACTORY_NAME=factory_name,
+          FACTORY_PARAMS=self.ParametersAsArgumentList())
+      return
+
+    # If we have optional parameters, check to see if they are set
+    # and call the appropriate factory method.
+    def EmitOptionalParameterInvocation(index):
+      emitter.Emit(
+        '    if (!?$(OPT_PARAM_NAME)) {\n'

[Anton Muhin, 2012/09/17 10:11:28]

nit: why OPT_PARAM_NAME is in parentheses? 

[blois, 2012/09/17 19:48:22]

Probably leftover from something else. Converted.

On 2012/09/17 10:11:28, Anton Muhin wrote:

+        '      return $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
+        '    }\n',
+        OPT_PARAM_NAME=self.param_infos[index].name,
+        FACTORY=factory_provider,
+        CTOR_FACTORY_NAME=factory_name,
+        FACTORY_PARAMS=self.ParametersAsArgumentList(index))
+
+    emitter.Emit(

[Anton Muhin, 2012/09/17 10:11:28]

I'd rather do something like:

dispatcher_emitter = emitter.Emit(
    '\n'
    '     factory $CTOR($PARAMS) {\n'
    ' $!DISPATCHER
    '       return $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
    '     }\n',
   ...)

and then alter EmitOptionalParameterInvocation to use dispatcher emitter
    

[blois, 2012/09/17 19:48:22]

Done. Wasn't aware of that trick!

On 2012/09/17 10:11:28, Anton Muhin wrote:

+        '\n  factory $CTOR($PARAMS) {\n',
+        CTOR=rename_type(self.ConstructorFullName()),
+        PARAMS=self.ParametersInterfaceDeclaration(rename_type))
+
+    index = 0
+    for param_info in self.param_infos:

[Anton Muhin, 2012/09/17 10:11:28]

for index, param_info in enumerate(self.param_infos) ?

[blois, 2012/09/17 19:48:22]

Done.

+      if param_info.is_optional:
+        EmitOptionalParameterInvocation(index)
+      index += 1
+
+    emitter.Emit(
+        '    return $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
+        FACTORY=factory_provider,
+        CTOR_FACTORY_NAME=factory_name,
+        FACTORY_PARAMS=self.ParametersAsArgumentList())
+
+    emitter.Emit('  }\n')
+
+
   def CopyAndWidenDefaultParameters(self):
     """Returns equivalent OperationInfo, but default parameters are Dynamic."""
     info = copy.copy(self)
     info.param_infos = [param.Copy() for param in self.param_infos]
     for param in info.param_infos:
       if param.is_optional:
         param.dart_type = 'Dynamic'
     return info
 
 
@@ skipping 471 matching lines @@
     if match:
       if type_name == 'DOMString[]':
         return DOMStringArrayTypeInfo(TypeData('Sequence'), self.TypeInfo('DOMString'))
       item_info = self.TypeInfo(match.group(1) or match.group(2))
       return SequenceIDLTypeInfo(type_name, TypeData('Sequence'), item_info)
     if not type_name in _idl_type_registry:
       return InterfaceIDLTypeInfo(type_name, TypeData('Interface'))
     type_data = _idl_type_registry.get(type_name)
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)