Initial overloading implementation in _blink

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, \
@@ skipping 18 matching lines @@
   'Location': 'LocationBase',
   'History': 'HistoryBase',
 }
 
 _custom_factories = [
   'Notification',
   'EventSource',
 ]
 
 class HtmlDartGenerator(object):
-  def __init__(self, interface, options):
+  def __init__(self, interface, options, dart_use_blink):
+    # This goes away after the Chrome 35 roll (or whenever we commit to the
+    # dart:blink refactor)
+    self._dart_use_blink = dart_use_blink
     self._database = options.database
     self._interface = interface
     self._type_registry = options.type_registry
     self._interface_type_info = self._type_registry.TypeInfo(self._interface.id)
     self._renamer = options.renamer
     self._metadata = options.metadata
     self._library_name = self._renamer.GetLibraryName(self._interface)
 
   def EmitSupportCheck(self):
     if self.HasSupportCheck():
@@ skipping 258 matching lines @@
     else:
       self.EmitOperation(info, method_name)
 
   def _GenerateOverloadDispatcher(self,
       info,
       signatures,
       is_void,
       declaration,
       generate_call,
       is_optional,
+      emitter,
       can_omit_type_check=lambda type, pos: False):
 
     parameter_names = [p.name for p in info.param_infos]
     number_of_required_in_dart = info.NumberOfRequiredInDart()
 
-    body_emitter = self._members_emitter.Emit(
+    body_emitter = emitter.Emit(
         '\n'
         '  $DECLARATION {\n'
         '$!BODY'
         '  }\n',
         DECLARATION=declaration)
 
     version = [0]
     def GenerateCall(signature_index, argument_count, checks):
       if checks:
         (stmts_emitter, call_emitter) = body_emitter.Emit(
@@ skipping 91 matching lines @@
 
     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)
 
+    emitter = \
+        self._native_library_emitter if self._dart_use_blink \
+        else self._members_emitter
+
     self._GenerateOverloadDispatcher(
         info,
         [operation.arguments for operation in operations],
         operations[0].type.id == 'void',
         declaration,
         GenerateCall,
         IsOptional,
+        emitter,
         can_omit_type_check)
 
   def AdditionalImplementedInterfaces(self):
     # TODO: Include all implemented interfaces, including other Lists.
     implements = []
     if self._interface_type_info.list_item_type():
       item_type = self._type_registry.TypeInfo(
           self._interface_type_info.list_item_type()).dart_type()
       implements.append('List<%s>' % item_type)
     return implements
@@ skipping 70 matching lines @@
             METADATA=metadata,
             FACTORY=factory_name,
             CTOR_FACTORY_NAME=factory_constructor_name,
             PARAMS=constructor_info.ParametersAsDeclaration(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:
+      custom_factory_ctr = self._interface.id in _custom_factories
+      constructor_full_name = constructor_info._ConstructorFullName(
+          self._DartType)
+
       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,
-            NAME=name,
+        if self._dart_use_blink:
+            qualified_name = \
+                "_".join(["Native",self._interface.id,
+                          name + 'constructorCallback'])
+        else:
+            qualified_name = emitter.Format(
+                '$FACTORY.$NAME',
+                FACTORY=factory_name,
+                NAME=name)
+        call_emitter.Emit('$FACTORY_NAME($FACTORY_PARAMS)',
+            FACTORY_NAME=qualified_name,
             FACTORY_PARAMS= \
                 constructor_info.ParametersAsArgumentList(argument_count))
         self.EmitStaticFactoryOverload(
             constructor_info, name,
             constructor_info.idl_args[signature_index][:argument_count])
 
       def IsOptional(signature_index, argument):
         return self.IsConstructorArgumentOptional(argument)
 
-      custom_factory_ctr = self._interface.id in _custom_factories
-      constructor_full_name = constructor_info._ConstructorFullName(
-          self._DartType)
+      entry_declaration = emitter.Format(
+          '$(METADATA)$FACTORY_KEYWORD $CTOR($PARAMS)',
+          FACTORY_KEYWORD=('factory' if not custom_factory_ctr else
+                           'static %s' % constructor_full_name),
+          CTOR=(('' if not custom_factory_ctr else '_factory')
+                + constructor_full_name),
+          METADATA=metadata,
+          PARAMS=constructor_info.ParametersAsDeclaration(self._DartType))
+
+      if self._dart_use_blink:
+          overload_emitter = self._native_library_emitter
+          mname = constructor_full_name.replace(".", "_")
+          blink_name = \
+              "_".join(["Native",self._interface.id, mname])
+          qual_name = self._native_library_name + "." + blink_name
+          actuals_s = constructor_info.ParametersAsStringOfVariables()
+          self._members_emitter.Emit(
+            '\n'
+            '  $DECLARATION => $NATIVE_NAME($ACTUALS);\n',
+            DECLARATION=entry_declaration,
+            NATIVE_NAME=qual_name,
+            ACTUALS=actuals_s)
+          overload_declaration = emitter.Format(
+              '// Generated overload resolver\n'
+              '$CTOR($PARAMS)',
+              CTOR=blink_name,
+              PARAMS=actuals_s)
+
+
+      else:
+          overload_emitter = self._members_emitter
+          overload_declaration = entry_declaration
+
       self._GenerateOverloadDispatcher(
           constructor_info,
           constructor_info.idl_args,
           False,
-          emitter.Format('$(METADATA)$FACTORY_KEYWORD $CTOR($PARAMS)',
-            FACTORY_KEYWORD=('factory' if not custom_factory_ctr else
-                'static %s' % constructor_full_name),
-            CTOR=(('' if not custom_factory_ctr else '_factory')
-                + constructor_full_name),
-            METADATA=metadata,
-            PARAMS=constructor_info.ParametersAsDeclaration(self._DartType)),
+          overload_declaration,
           GenerateCall,
-          IsOptional)
+          IsOptional,
+          overload_emitter)
 
   def _AddFutureifiedOperation(self, info, html_name):
     """Given a API function that uses callbacks, convert it to using Futures.
 
     This conversion assumes the success callback is always provided before the
     error callback (and so far in the DOM API, this is the case)."""
     callback_info = GetCallbackInfo(
         self._database.GetInterface(info.callback_args[0].type_id))
 
     param_list = info.ParametersAsArgumentList()
@@ skipping 132 matching lines @@
 
   def SecureBaseName(self, type_name):
     if type_name in _secure_base_types:
       return _secure_base_types[type_name]
 
   def _DartType(self, type_name):
     return self._type_registry.DartType(type_name)
 
   def _TypeInfo(self, type_name):
     return self._type_registry.TypeInfo(type_name)