Dispatch with conversion hooks

lib/dom/scripts/systemhtml.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
 
@@ skipping 880 matching lines @@
     if self._interface.id != 'NodeList':
       template_file = 'immutable_list_mixin.darttemplate'
       template = self._system._templates.Load(template_file)
       self._members_emitter.Emit(template, E=self._DartType(element_type))
 
   def AddAttribute(self, attribute, html_name, read_only):
     if self._HasCustomImplementation(attribute.id):
       return
 
     if attribute.id != html_name:
-      self._AddRenamingGetter(attribute, html_name)
-      if not read_only:
-        self._AddRenamingSetter(attribute, html_name)
+      self._AddAttributeUsingProperties(attribute, html_name, read_only)
       return
 
     # If the attribute is shadowing, we can't generate a shadowing
     # field (Issue 1633).
-    (super_attribute, super_attribute_interface) = self._FindShadowedAttribute(attribute, _merged_html_interfaces)
+    # TODO(sra): _FindShadowedAttribute does not take into account the html
+    #  renaming.  we should be looking for another attribute that has the same
+    #  html_name.  Two attributes with the same IDL name might not match if one
+    #  is renamed.
+    (super_attribute, super_attribute_interface) = self._FindShadowedAttribute(
+        attribute, _merged_html_interfaces)
     if super_attribute:
       if read_only:
         if attribute.type.id == super_attribute.type.id:
           # Compatible attribute, use the superclass property.  This works
           # because JavaScript will do its own dynamic dispatch.
           self._members_emitter.Emit(
               '\n'
               '  // Use implementation from $SUPER.\n'
               '  // final $TYPE $NAME;\n',
               SUPER=super_attribute_interface,
               NAME=DartDomNameOfAttribute(attribute),
               TYPE=self._NarrowOutputType(attribute.type.id))
           return
+      self._members_emitter.Emit('\n  // Shadowing definition.')
+      self._AddAttributeUsingProperties(attribute, html_name, read_only)
+      return
 
-      self._members_emitter.Emit('\n  // Shadowing definition.')
-      self._AddAttributeUsingProperties(attribute, read_only)
+    # If the type has a conversion we need a getter or setter to contain the
+    # conversion code.
+    if (self._OutputConversion(attribute.type.id, attribute.id) or
+        self._InputConversion(attribute.type.id, attribute.id)):
+      self._AddAttributeUsingProperties(attribute, html_name, read_only)
       return
 
     output_type = self._NarrowOutputType(attribute.type.id)
     input_type = self._NarrowInputType(attribute.type.id)
     if not read_only:
       self._members_emitter.Emit(
           '\n  $TYPE $NAME;\n',
           NAME=DartDomNameOfAttribute(attribute),
           TYPE=output_type)
     else:
       self._members_emitter.Emit(
           '\n  final $TYPE $NAME;\n',
           NAME=DartDomNameOfAttribute(attribute),
           TYPE=output_type)
 
-  def _AddAttributeUsingProperties(self, attribute, read_only):
-    self._AddGetter(attribute)
+  def _AddAttributeUsingProperties(self, attribute, html_name, read_only):
+    self._AddRenamingGetter(attribute, html_name)
     if not read_only:
-      self._AddSetter(attribute)
-
-  def _AddGetter(self, attr):
-    self._AddRenamingGetter(attr, DartDomNameOfAttribute(attr))
-
-  def _AddSetter(self, attr):
-    self._AddRenamingSetter(attr, DartDomNameOfAttribute(attr))
+      self._AddRenamingSetter(attribute, html_name)
 
   def _AddRenamingGetter(self, attr, html_name):
+    conversion = self._OutputConversion(attr.type.id, attr.id)
+    if conversion:
+      return self._AddConvertingGetter(attr, html_name, conversion)
     return_type = self._NarrowOutputType(attr.type.id)
     self._members_emitter.Emit(
-        '\n  $TYPE get $(HTML_NAME)() native "return this.$NAME;";\n',
+        '\n  $TYPE get $HTML_NAME() native "return this.$NAME;";\n',
         HTML_NAME=html_name,
         NAME=attr.id,
         TYPE=return_type)
 
   def _AddRenamingSetter(self, attr, html_name):
+    conversion = self._InputConversion(attr.type.id, attr.id)
+    if conversion:
+      return self._AddConvertingSetter(attr, html_name, conversion)
     self._members_emitter.Emit(
         '\n  void set $HTML_NAME($TYPE value)'
         ' native "this.$NAME = value;";\n',
         HTML_NAME=html_name,
         NAME=attr.id,
         TYPE=self._NarrowInputType(attr.type.id))
 
+  def _AddConvertingGetter(self, attr, html_name, conversion):
+    self._members_emitter.Emit(
+        '\n  $RETURN_TYPE get $HTML_NAME() => $CONVERT(this._$(HTML_NAME));'
+        '\n  $NATIVE_TYPE get _$HTML_NAME() native "return this.$NAME;";'
+        '\n',
+        CONVERT=conversion.function_name,
+        HTML_NAME=html_name,
+        NAME=attr.id,
+        RETURN_TYPE=conversion.output_type,
+        NATIVE_TYPE=conversion.input_type)
+
+  def _AddConvertingSetter(self, attr, html_name, conversion):
+    self._members_emitter.Emit(
+        '\n  void set $HTML_NAME($INPUT_TYPE value) {'
+        ' this._$HTML_NAME = $CONVERT(value); }'
+        '\n  void set _$HTML_NAME(/*$NATIVE_TYPE*/ value)'
+        ' native "this.$NAME = value;";'
+        '\n',
+        CONVERT=conversion.function_name,
+        HTML_NAME=html_name,
+        NAME=attr.id,
+        INPUT_TYPE=conversion.input_type,
+        NATIVE_TYPE=conversion.output_type)
+
+
   def AddOperation(self, info, html_name):
     """
     Arguments:
       info: An OperationInfo object.
     """
     if self._HasCustomImplementation(info.name):
       return
 
     # FIXME: support static operations.
     if info.IsStatic():
       return
 
+    # Any conversions needed?
+    if any(self._OperationRequiresConversions(op) for op in info.overloads):
+      self._AddOperationWithConversions(info, html_name)
+    else:
+      self._AddDirectNativeOperation(info, html_name)
+
+  def _AddDirectNativeOperation(self, info, html_name):
     # Do we need a native body?
     if html_name != info.declared_name:
       return_type = self._NarrowOutputType(info.type_name)
 
       operation_emitter = self._members_emitter.Emit('$!SCOPE',
           TYPE=return_type,
           HTML_NAME=html_name,
           NAME=info.declared_name,
           PARAMS=info.ParametersImplementationDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
       operation_emitter.Emit(
           '\n'
+          #'  // @native("$NAME")\n;'
           '  $TYPE $(HTML_NAME)($PARAMS) native "$NAME";\n')
     else:
       self._members_emitter.Emit(
           '\n'
           '  $TYPE $NAME($PARAMS) native;\n',
           TYPE=self._NarrowOutputType(info.type_name),
           NAME=info.name,
           PARAMS=info.ParametersImplementationDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
+  def _AddOperationWithConversions(self, info, html_name):
+    # Assert all operations have same return type.
+    assert len(set([op.type.id for op in info.operations])) == 1
+    info = info.CopyAndWidenDefaultParameters()
+    output_conversion = self._OutputConversion(info.type_name,
+                                               info.declared_name)
+    if output_conversion:
+      return_type = output_conversion.output_type
+      native_return_type = output_conversion.input_type
+    else:
+      return_type = self._NarrowInputType(info.type_name)
+      native_return_type = return_type
+
+    def InputType(type_name):
+      conversion = self._InputConversion(type_name, info.declared_name)
+      if conversion:
+        return conversion.input_type
+      else:
+        return self._NarrowInputType(type_name)
+
+    body = self._members_emitter.Emit(
+        '\n'
+        '  $TYPE $(HTML_NAME)($PARAMS) {\n'
+        '$!BODY'
+        '  }\n',
+        TYPE=return_type,
+        HTML_NAME=html_name,
+        PARAMS=info.ParametersImplementationDeclaration(InputType, '_default'))
+
+    argument_names = [param_info.name for param_info in info.param_infos]
+    argument_types = [InputType(param_info.dart_type)
+                      for param_info in info.param_infos]
+    operations = info.operations
+
+    method_version = [0]
+    temp_version = [0]
+
+    def GenerateCall(operation, argument_count, checks):
+      if checks:
+        (stmts_emitter, call_emitter) = body.Emit(
+            '    if ($CHECKS) {\n$!STMTS$!CALL    }\n',
+            INDENT='      ',
+            CHECKS=' &&\n        '.join(checks))
+      else:
+        (stmts_emitter, call_emitter) = body.Emit('$!A$!B', INDENT='    ');
+
+      method_version[0] += 1
+      target = '_%s_%d' % (html_name, method_version[0])
+      arguments = []
+      target_parameters = []
+      for position, arg in enumerate(operation.arguments[:argument_count]):
+        conversion = self._InputConversion(arg.type.id, operation.id)
+        param_name = operation.arguments[position].id
+        if conversion:
+          temp_version[0] += 1
+          temp_name = '%s_%s' % (param_name, temp_version[0])
+          temp_type = conversion.output_type
+          stmts_emitter.Emit(
+              '$(INDENT)$TYPE $NAME = $CONVERT($ARG);\n',
+              TYPE=TypeOrVar(temp_type),
+              NAME=temp_name,
+              CONVERT=conversion.function_name,
+              ARG=argument_names[position])
+          arguments.append(temp_name)
+          param_type = temp_type
+          verified_type = temp_type  # verified by assignment in checked mode.
+        else:
+          arguments.append(argument_names[position])
+          param_type = self._NarrowInputType(DartType(arg.type.id))
+          # Verified by argument checking on entry to the dispatcher.
+          verified_type = InputType(info.param_infos[position].dart_type)
+
+        # The native method does not need an argument type if we know the type.
+        # But we do need the native methods to have correct function types, so
+        # be conservative.
+        if param_type == verified_type:
+          if param_type in ['String', 'num', 'int', 'double', 'bool', 'Object']:
+            param_type = 'Dynamic'
+        target_parameters.append(
+            '%s%s' % (TypeOrNothing(param_type), param_name))
+
+      argument_list = ', '.join(arguments)
+      # TODO(sra): If the native method has zero type checks, we can 'inline' is
+      # and call it directly with a JS-expression.
+      call = '%s(%s)' % (target, argument_list)
+
+      if output_conversion:
+        call = '%s(%s)' % (output_conversion.function_name, call)
+
+      if operation.type.id == 'void':
+        call_emitter.Emit('$(INDENT)$CALL;\n$(INDENT)return;\n',
+                          CALL=call)
+      else:
+        call_emitter.Emit('$(INDENT)return $CALL;\n', CALL=call)
+
+      self._members_emitter.Emit(
+          '  $TYPE$TARGET($PARAMS) native "$NATIVE";\n',
+          TYPE=TypeOrNothing(native_return_type),
+          TARGET=target,
+          PARAMS=', '.join(target_parameters),
+          NATIVE=info.declared_name)
+
+    def GenerateChecksAndCall(operation, argument_count):
+      checks = ['_default == %s' % name for name in argument_names]
+      for i in range(0, argument_count):
+        argument = operation.arguments[i]
+        argument_name = argument_names[i]
+        test_type = self._DartType(argument.type.id)
+        if test_type in ['Dynamic', 'Object']:
+          checks[i] = '_default != %s' % argument_name
+        else:
+          checks[i] = '(%s is %s || %s == null)' % (
+              argument_name, self._DartType(argument.type.id), argument_name)
+      GenerateCall(operation, 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 self._IsOptional(operation, argument):
+            GenerateChecksAndCall(operation, position)
+        GenerateChecksAndCall(operation, len(operation.arguments))
+      body.Emit('    throw "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 self._IsOptional(operation, argument):
+          check = '_default != %s' % argument_names[position]
+          GenerateCall(operation, position + 1, [check])
+          argument_count = position
+      GenerateCall(operation, argument_count, [])
+
+
+  def _IsOptional(self, operation, argument):
+    return IsOptional(argument)
+
+
+  def _OperationRequiresConversions(self, operation):
+    return (self._OperationRequiresOutputConversion(operation) or
+            self._OperationRequiresInputConversions(operation))
+
+  def _OperationRequiresOutputConversion(self, operation):
+    return self._OutputConversion(operation.type.id, operation.id)
+
+  def _OperationRequiresInputConversions(self, operation):
+    return any(self._InputConversion(arg.type.id, operation.id)
+               for arg in operation.arguments)
+
+  def _OutputConversion(self, idl_type, member):
+    return FindConversion(idl_type, 'get', self._interface.id, member)
+
+  def _InputConversion(self, idl_type, member):
+    return FindConversion(idl_type, 'set', self._interface.id, member)
+
   def _HasCustomImplementation(self, member_name):
     member_name = '%s.%s' % (self._html_interface_name, member_name)
     return member_name in _js_custom_members
 
   def _HasJavaScriptIndexingBehaviour(self):
     """Returns True if the native object has an indexer and length property."""
     (element_type, requires_indexer) = ListImplementationInfo(
         self._interface, self._database)
     if element_type and requires_indexer: return True
     return False
 
 # ------------------------------------------------------------------------------
 
 class HtmlDart2JSSystem(System):
 
   def __init__(self, options):
     super(HtmlDart2JSSystem, self).__init__(options)
 
   def ImplementationGenerator(self, interface):
     return HtmlDart2JSClassGenerator(self, interface)
 
   def GenerateLibraries(self, dart_files):
     self._GenerateLibFile(
         'html_dart2js.darttemplate',
         os.path.join(self._output_dir, 'html_dart2js.dart'),
         dart_files)
 
   def Finish(self):
     pass