Support overloaded constructors.

tools/dom/scripts/htmldartgenerator.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 system to generate
 dart:html APIs from the IDL database."""
 
+import emitter
 from generator import AnalyzeOperation, ConstantOutputOrder, \
     DartDomNameOfAttribute, FindMatchingAttribute, IsDartCollectionType, \
     IsPureInterface, TypeOrNothing
 
 # Types that are accessible cross-frame in a limited fashion.
 # In these cases, the base type (e.g., WindowBase) provides restricted access
 # while the subtype (e.g., Window) provides full access to the
 # corresponding objects if there are from the same frame.
 _secure_base_types = {
   'Window': 'WindowBase',
@@ skipping 150 matching lines @@
         # FIXME: item should be renamed to operator[], not removed.
         self.EmitOperation(info, '_item')
       return
 
     if declare_only:
       self.DeclareOperation(info,
           self.SecureOutputType(info.type_name), method_name)
     else:
       self.EmitOperation(info, method_name)
 
-  def _GenerateDispatcherBody(self,
-      operations,
+  def _GenerateOverloadDispatcher(self,
+      signatures,
+      is_void,
       parameter_names,
       declaration,
       generate_call,
       is_optional,
       can_omit_type_check=lambda type, pos: False):
 
     body_emitter = self._members_emitter.Emit(
         '\n'
         '  $DECLARATION {\n'
         '$!BODY'
         '  }\n',
         DECLARATION=declaration)
 
     version = [0]
-    def GenerateCall(operation, argument_count, checks):
+    def GenerateCall(signature_index, argument_count, checks):
       if checks:
         (stmts_emitter, call_emitter) = body_emitter.Emit(
             '    if ($CHECKS) {\n$!STMTS$!CALL    }\n',
             INDENT='      ',
             CHECKS=' && '.join(checks))
       else:
         (stmts_emitter, call_emitter) = body_emitter.Emit(
             '$!STMTS$!CALL',
             INDENT='    ');
 
-      if operation.type.id == 'void':
+      if is_void:
         call_emitter = call_emitter.Emit('$(INDENT)$!CALL;\n$(INDENT)return;\n')
       else:
         call_emitter = call_emitter.Emit('$(INDENT)return $!CALL;\n')
 
       version[0] += 1
-      generate_call(
-          stmts_emitter, call_emitter, version[0], operation, argument_count)
+      generate_call(stmts_emitter, call_emitter,
+          version[0], signature_index, argument_count)
 
-    def GenerateChecksAndCall(operation, argument_count):
+    def GenerateChecksAndCall(signature_index, argument_count):
       checks = []
       for i in range(0, argument_count):
-        argument = operation.arguments[i]
+        argument = signatures[signature_index][i]
         parameter_name = parameter_names[i]
         test_type = self._DartType(argument.type.id)
         if test_type in ['dynamic', 'Object']:
           checks.append('?%s' % parameter_name)
         elif not can_omit_type_check(test_type, i):
           checks.append('(%s is %s || %s == null)' % (
               parameter_name, test_type, parameter_name))
       # There can be multiple presence checks.  We need them all since a later
       # optional argument could have been passed by name, leaving 'holes'.
       checks.extend(['!?%s' % name for name in parameter_names[argument_count:]])
 
-      GenerateCall(operation, argument_count, checks)
+      GenerateCall(signature_index, argument_count, checks)
 
     # TODO: Optimize the dispatch to avoid repeated checks.
-    if len(operations) > 1:
-      for operation in operations:
-        for position, argument in enumerate(operation.arguments):
-          if is_optional(operation, argument):
-            GenerateChecksAndCall(operation, position)
-        GenerateChecksAndCall(operation, len(operation.arguments))
+    if len(signatures) > 1:
+      for signature_index, signature in enumerate(signatures):
+        for argument_position, argument in enumerate(signature):
+          if is_optional(signature_index, argument):
+            GenerateChecksAndCall(signature_index, argument_position)
+        GenerateChecksAndCall(signature_index, len(signature))
       body_emitter.Emit(
           '    throw new ArgumentError("Incorrect number or type of arguments");'
           '\n');
     else:
-      operation = operations[0]
-      argument_count = len(operation.arguments)
-      for position, argument in list(enumerate(operation.arguments))[::-1]:
-        if is_optional(operation, argument):
-          check = '?%s' % parameter_names[position]
-          # argument_count instead of position + 1 is used here to cover one
+      signature = signatures[0]
+      argument_count = len(signature)
+      for argument_position, argument in list(enumerate(signature))[::-1]:
+        if is_optional(0, argument):
+          check = '?%s' % parameter_names[argument_position]
+          # argument_count instead of argument_position + 1 is used here to cover one
           # complicated case with the effectively optional argument in the middle.
           # Consider foo(x, [Optional] y, [Optional=DefaultIsNullString] z)
           # (as of now it's modelled after HTMLMediaElement.webkitAddKey).
           # y is optional in WebCore, while z is not.
           # In this case, if y was actually passed, we'd like to emit foo(x, y, z) invocation,
           # not foo(x, y).
-          GenerateCall(operation, argument_count, [check])
-          argument_count = position
-      GenerateCall(operation, argument_count, [])
+          GenerateCall(0, argument_count, [check])
+          argument_count = argument_position
+      GenerateCall(0, argument_count, [])
+
+  def _GenerateDispatcherBody(self,
+      operations,
+      parameter_names,
+      declaration,
+      generate_call,
+      is_optional,
+      can_omit_type_check=lambda type, pos: False):
+
+    def GenerateCall(
+        stmts_emitter, call_emitter, version, signature_index, argument_count):
+      generate_call(
+          stmts_emitter, call_emitter,
+          version, operations[signature_index], argument_count)
+
+    def IsOptional(signature_index, argument):
+      return is_optional(operations[signature_index], argument)
+
+    self._GenerateOverloadDispatcher(
+        [operation.arguments for operation in operations],
+        operations[0].type.id == 'void',
+        parameter_names,
+        declaration,
+        GenerateCall,
+        IsOptional,
+        can_omit_type_check)
 
   def AdditionalImplementedInterfaces(self):
     # TODO: Include all implemented interfaces, including other Lists.
     implements = []
     if self._interface_type_info.is_typed_array():
       element_type = self._interface_type_info.list_item_type()
       implements.append('List<%s>' % self._DartType(element_type))
     if self._interface_type_info.list_item_type():
       item_type_info = self._type_registry.TypeInfo(
           self._interface_type_info.list_item_type())
@@ skipping 31 matching lines @@
           '\n'
           '  factory $CTOR.fromBuffer(ArrayBuffer buffer, '
               '[int byteOffset, int length]) => \n'
           '    $FACTORY.create$(CTOR)_fromBuffer(buffer, byteOffset, length);\n',
         CTOR=self._interface.id,
         TYPE=self._DartType(typed_array_type),
         FACTORY=factory_name)
 
   def _AddConstructor(self,
       constructor_info, factory_name, factory_constructor_name):
+    if self.GenerateCustomFactory(constructor_info):
+      return
+
     self._members_emitter.Emit('\n  @DocsEditable');
 
     if not factory_constructor_name:
       factory_constructor_name = '_create'
       factory_parameters = constructor_info.ParametersAsArgumentList()
       has_factory_provider = True
     else:
       factory_parameters = ', '.join(constructor_info.factory_parameters)
       has_factory_provider = False
 
-    has_optional = any(param_info.is_optional
-        for param_info in constructor_info.param_infos)
+    if constructor_info.pure_dart_constructor:
+      # TODO(antonm): use common dispatcher generation for this case as well.
+      has_optional = any(param_info.is_optional
+          for param_info in constructor_info.param_infos)
 
-    if not has_optional:
-      self._members_emitter.Emit(
-          '\n'
-          '  factory $CTOR($PARAMS) => '
-          '$FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
-          CTOR=constructor_info._ConstructorFullName(self._DartType),
-          PARAMS=constructor_info.ParametersDeclaration(self._DartType),
-          FACTORY=factory_name,
-          CTOR_FACTORY_NAME=factory_constructor_name,
-          FACTORY_PARAMS=factory_parameters)
-    else:
-      if has_factory_provider:
-        dispatcher_emitter = self._members_emitter.Emit(
+      if not has_optional:
+        self._members_emitter.Emit(
             '\n'
-            '  factory $CTOR($PARAMS) {\n'
-            '$!DISPATCHER'
-            '    return $FACTORY._create($FACTORY_PARAMS);\n'
-            '  }\n',
+            '  factory $CTOR($PARAMS) => '
+            '$FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
             CTOR=constructor_info._ConstructorFullName(self._DartType),
             PARAMS=constructor_info.ParametersDeclaration(self._DartType),
             FACTORY=factory_name,
-            FACTORY_PARAMS=constructor_info.ParametersAsArgumentList())
+            CTOR_FACTORY_NAME=factory_constructor_name,
+            FACTORY_PARAMS=factory_parameters)
+      else:
+        if has_factory_provider:
+          dispatcher_emitter = self._members_emitter.Emit(
+              '\n'
+              '  factory $CTOR($PARAMS) {\n'
+              '$!DISPATCHER'
+              '    return $FACTORY._create($FACTORY_PARAMS);\n'
+              '  }\n',
+              CTOR=constructor_info._ConstructorFullName(self._DartType),
+              PARAMS=constructor_info.ParametersDeclaration(self._DartType),
+              FACTORY=factory_name,
+              FACTORY_PARAMS=constructor_info.ParametersAsArgumentList())
 
-        for index, param_info in enumerate(constructor_info.param_infos):
-          if param_info.is_optional:
-            dispatcher_emitter.Emit(
-              '    if (!?$OPT_PARAM_NAME) {\n'
-              '      return $FACTORY._create($FACTORY_PARAMS);\n'
-              '    }\n',
-              OPT_PARAM_NAME=param_info.name,
+          for index, param_info in enumerate(constructor_info.param_infos):
+            if param_info.is_optional:
+              dispatcher_emitter.Emit(
+                '    if (!?$OPT_PARAM_NAME) {\n'
+                '      return $FACTORY._create($FACTORY_PARAMS);\n'
+                '    }\n',
+                OPT_PARAM_NAME=param_info.name,
+                FACTORY=factory_name,
+                FACTORY_PARAMS=constructor_info.ParametersAsArgumentList(index))
+        else:
+          inits = self._members_emitter.Emit(
+              '\n'
+              '  factory $CONSTRUCTOR($PARAMS) {\n'
+              '    var e = $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
+              '$!INITS'
+              '    return e;\n'
+              '  }\n',
+              CONSTRUCTOR=constructor_info._ConstructorFullName(self._DartType),
               FACTORY=factory_name,
-              FACTORY_PARAMS=constructor_info.ParametersAsArgumentList(index))
-      else:
-        inits = self._members_emitter.Emit(
-            '\n'
-            '  factory $CONSTRUCTOR($PARAMS) {\n'
-            '    var e = $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
-            '$!INITS'
-            '    return e;\n'
-            '  }\n',
-            CONSTRUCTOR=constructor_info._ConstructorFullName(self._DartType),
+              CTOR_FACTORY_NAME=factory_constructor_name,
+              PARAMS=constructor_info.ParametersDeclaration(self._DartType),
+              FACTORY_PARAMS=factory_parameters)
+
+          for index, param_info in enumerate(constructor_info.param_infos):
+            if param_info.is_optional:
+              inits.Emit('    if ($E != null) e.$E = $E;\n', E=param_info.name)
+    else:
+      def GenerateCall(
+          stmts_emitter, call_emitter,
+          version, signature_index, argument_count):
+        name = emitter.Format('_create_$VERSION', VERSION=version)
+        call_emitter.Emit('$FACTORY.$NAME($FACTORY_PARAMS)',
             FACTORY=factory_name,
-            CTOR_FACTORY_NAME=factory_constructor_name,
-            PARAMS=constructor_info.ParametersDeclaration(self._DartType),
-            FACTORY_PARAMS=factory_parameters)
+            NAME=name,
+            FACTORY_PARAMS= \
+                constructor_info.ParametersAsArgumentList(argument_count))
+        self.EmitStaticFactoryOverload(
+            constructor_info, name,
+            constructor_info.idl_args[signature_index][:argument_count])
 
-        for index, param_info in enumerate(constructor_info.param_infos):
-          if param_info.is_optional:
-            inits.Emit('    if ($E != null) e.$E = $E;\n', E=param_info.name)
+      def IsOptional(signature_index, argument):
+        return self.IsConstructorArgumentOptional(argument)
 
-    if not constructor_info.pure_dart_constructor:
-      self.EmitStaticFactory(constructor_info)
+      self._GenerateOverloadDispatcher(
+          constructor_info.idl_args,
+          False,
+          [info.name for info in constructor_info.param_infos],
+          emitter.Format('factory $CTOR($PARAMS)',
+            CTOR=constructor_info._ConstructorFullName(self._DartType),
+            PARAMS=constructor_info.ParametersDeclaration(self._DartType)),
+          GenerateCall,
+          IsOptional)
 
   def EmitHelpers(self, base_class):
     pass
 
   def DeclareAttribute(self, attribute, type_name, attr_name, read_only):
     """ Declares an attribute but does not include the code to invoke it.
     """
     if read_only:
       template = '\n  $TYPE get $NAME;\n'
     else:
@@ skipping 89 matching lines @@
         walk(interface.parents)
       else:
         walk(interface.parents[1:])
     return result
 
   def _DartType(self, type_name):
     return self._type_registry.DartType(type_name)
 
   def _IsPrivate(self, name):
     return name.startswith('_')