Remove JS from wrapping implementation.

client/dom/scripts/dartgenerator.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 generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 1010 matching lines @@
   def __init__(self, templates, database, emitters, output_dir):
     """Prepared for generating wrapping implementation.
 
     - Creates emitter for JS code.
     - Creates emitter for Dart code.
     """
     super(WrappingImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._dart_wrapping_file_paths = []
 
-    js_file_name = os.path.join(output_dir, 'wrapping_dom.js')
-    code = self._emitters.FileEmitter(js_file_name)
-    template = self._templates.Load('wrapping_dom.js')
-    (self._wrapping_js_natives,
-     self._wrapping_map) = code.Emit(template)
-
-    _logger.info('Started Generating %s' % js_file_name)
-
-    # Set of (interface, name, kind), kind is 'attribute' or 'operation'.
-    self._wrapping_externs = set()
-
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     interface_name = interface.id
     dart_wrapping_file_path = self._FilePathForDartWrappingImpl(interface_name)
 
     self._dart_wrapping_file_paths.append(dart_wrapping_file_path)
 
     dart_code = self._emitters.FileEmitter(dart_wrapping_file_path)
     dart_code.Emit(self._templates.Load('wrapping_impl.darttemplate'))
     return WrappingInterfaceGenerator(interface, super_interface_name,
-                                      dart_code, self._wrapping_js_natives,
-                                      self._wrapping_map,
-                                      self._wrapping_externs,
+                                      dart_code,
                                       self._BaseDefines(interface))
 
   def ProcessCallback(self, interface, info):
     pass
 
   def GenerateLibraries(self, lib_dir):
     # Library generated for implementation.
     self._GenerateLibFile(
         'wrapping_dom.darttemplate',
         os.path.join(lib_dir, 'wrapping_dom.dart'),
         (self._interface_system._dart_interface_file_paths +
          self._interface_system._dart_callback_file_paths +
          # FIXME: Move the implementation to a separate library.
          self._dart_wrapping_file_paths
          ))
 
 
   def Finish(self):
-    self._GenerateJavaScriptExternsWrapping(self._database, self._output_dir)
+    pass
 
 
   def _FilePathForDartWrappingImpl(self, interface_name):
     """Returns the file path of the Dart wrapping implementation."""
     return os.path.join(self._output_dir, 'src', 'wrapping',
                         '_%sWrappingImplementation.dart' % interface_name)
 
-  def _GenerateJavaScriptExternsWrapping(self, database, output_dir):
-    """Generates a JavaScript externs file.
-
-    Generates an externs file that is consistent with generated JavaScript code
-    and Dart APIs for the wrapping implementation.
-    """
-    externs_file_name = os.path.join(output_dir, 'wrapping_dom_externs.js')
-    code = self._emitters.FileEmitter(externs_file_name)
-    _logger.info('Started generating %s' % externs_file_name)
-
-    template = self._templates.Load('wrapping_dom_externs.js')
-    namespace = 'dom_externs'
-    members = code.Emit(template, NAMESPACE=namespace)
-
-    # TODO: Filter out externs that are known to the JavaScript back-end.  Some
-    # of the known externs have useful declarations like @nosideeffects that
-    # might improve back-end analysis.
-
-    names = dict()  # maps name to (interface, kind)
-    for (interface, name, kind) in self._wrapping_externs:
-      if name not in _javascript_keywords:
-        if name not in names:
-          names[name] = set()
-        names[name].add((interface, kind))
-
-    for name in sorted(names.keys()):
-      # Simply export the property name.
-      extern = emitter.Format('$NAMESPACE.$NAME;',
-                              NAMESPACE=namespace, NAME=name)
-      members.EmitRaw(extern)
-      # Add a big comment of all the attributes and operations contributing to
-      # the export.
-      filler = ' ' * (40 - 2 - len(extern))  # '2' for 2 spaces before comment.
-      separator = filler + '  //'
-      for (interface, kind) in sorted(names[name]):
-        members.Emit('$SEP $KIND $INTERFACE.$NAME',
-                     NAME=name, INTERFACE=interface, KIND=kind, SEP=separator)
-        separator = ','
-      members.Emit('\n')
-
 # ------------------------------------------------------------------------------
 
 class FrogSystem(System):
 
   def __init__(self, templates, database, emitters, output_dir):
     super(FrogSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._dart_frog_file_paths = []
 
   def InterfaceGenerator(self,
@@ skipping 219 matching lines @@
     pass
 
   def AddOperation(self, info):
     pass
 
 # ------------------------------------------------------------------------------
 
 class WrappingInterfaceGenerator(object):
   """Generates Dart and JS implementation for one DOM IDL interface."""
 
-  def __init__(self, interface, super_interface, dart_code, js_code, type_map,
-               externs, base_members):
+  def __init__(self, interface, super_interface, dart_code, base_members):
     """Generates Dart and JS code for the given interface.
 
     Args:
 
       interface: an IDLInterface instance. It is assumed that all types have
           been converted to Dart types (e.g. int, String), unless they are in
           the same package as the interface.
       super_interface: A string or None, the name of the common interface that
          this interface implements, if any.
       dart_code: an Emitter for the file containing the Dart implementation
           class.
-      js_code: an Emitter for the file containing JS code.
-      type_map: an Emitter for the map from tokens to wrapper factory.
-      externs: a set of (class, property, kind) externs.  kind is 'attribute' or
-          'operation'.
       base_members: a set of names of members defined in a base class.  This is
           used to avoid static member 'overriding' in the generated Dart code.
     """
     self._interface = interface
     self._super_interface = super_interface
     self._dart_code = dart_code
-    self._js_code = js_code
-    self._type_map = type_map
-    self._externs = externs
     self._base_members = base_members
     self._current_secondary_parent = None
 
 
   def StartInterface(self):
     interface = self._interface
     interface_name = interface.id
 
     self._class_name = self._ImplClassName(interface_name)
-    self._type_map.Emit('  "$INTERFACE": native_$(CLASS)_create_$(CLASS),\n',
-                        INTERFACE=interface_name, CLASS=self._class_name)
 
     base = self._BaseClassName(interface)
 
     (self._members_emitter,
      self._top_level_emitter) = self._dart_code.Emit(
         '\n'
         'class $CLASS extends $BASE implements $INTERFACE {\n'
         '  $CLASS() : super() {}\n'
         '\n'
         '  static create_$CLASS() native {\n'
@@ skipping 58 matching lines @@
   def _AddGetter(self, attr):
     # FIXME: Instead of injecting the interface name into the method when it is
     # also implemented in the base class, suppress the method altogether if it
     # has the same signature.  I.e., let the JS do the virtual dispatch instead.
     method_name = self._MethodName('_get_', attr.id)
     self._members_emitter.Emit(
         '\n'
         '  $TYPE get $NAME() { return $METHOD(this); }\n'
         '  static $TYPE $METHOD(var _this) native;\n',
         NAME=attr.id, TYPE=attr.type.id, METHOD=method_name)
-    if (self._interface.id, attr.id) not in _custom_getters:
-      self._js_code.Emit(
-          '\n'
-          'function native_$(CLASS)_$(METHOD)(_this) {\n'
-          '  try {\n'
-          '    return __dom_wrap(_this.$dom.$NAME);\n'
-          '  } catch (e) {\n'
-          '    throw __dom_wrap_exception(e);\n'
-          '  }\n'
-          '}\n',
-          CLASS=self._class_name, NAME=attr.id, METHOD=method_name)
-      self._externs.add((self._interface.id, attr.id, 'attribute'))
 
   def _AddSetter(self, attr):
     # FIXME: See comment on getter.
     method_name = self._MethodName('_set_', attr.id)
     self._members_emitter.Emit(
         '\n'
         '  void set $NAME($TYPE value) { $METHOD(this, value); }\n'
         '  static void $METHOD(var _this, $TYPE value) native;\n',
         NAME=attr.id, TYPE=attr.type.id, METHOD=method_name)
-    self._js_code.Emit(
-        '\n'
-        'function native_$(CLASS)_$(METHOD)(_this, value) {\n'
-        '  try {\n'
-        '    _this.$dom.$NAME = __dom_unwrap(value);\n'
-        '  } catch (e) {\n'
-        '    throw __dom_wrap_exception(e);\n'
-        '  }\n'
-        '}\n',
-        CLASS=self._class_name, NAME=attr.id, METHOD=method_name)
-    self._externs.add((self._interface.id, attr.id, 'attribute'))
 
   def AddSecondaryAttribute(self, interface, getter, setter):
     self._SecondaryContext(interface)
     self.AddAttribute(getter, setter)
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
   def _SecondaryContext(self, interface):
@@ skipping 133 matching lines @@
     return ('HasIndexGetter' in interface.ext_attrs or
             'HasNumericIndexGetter' in interface.ext_attrs)
 
   def _EmitNativeIndexGetter(self, interface, element_type):
     method_name = '_index'
     self._members_emitter.Emit(
         '\n'
         '  $TYPE operator[](int index) { return $METHOD(this, index); }\n'
         '  static $TYPE $METHOD(var _this, int index) native;\n',
         TYPE=element_type, METHOD=method_name)
-    self._js_code.Emit(
-        '\n'
-        'function native_$(CLASS)_$(METHOD)(_this, index) {\n'
-        '  try {\n'
-        '    return __dom_wrap(_this.$dom[index]);\n'
-        '  } catch (e) {\n'
-        '    throw __dom_wrap_exception(e);\n'
-        '  }\n'
-        '}\n',
-        CLASS=self._class_name, METHOD=method_name)
 
   def _HasNativeIndexSetter(self, interface):
     return 'HasCustomIndexSetter' in interface.ext_attrs
 
   def _EmitNativeIndexSetter(self, interface, element_type):
     method_name = '_set_index'
     self._members_emitter.Emit(
         '\n'
         '  void operator[]=(int index, $TYPE value) {\n'
         '    return $METHOD(this, index, value);\n'
         '  }\n'
         '  static $METHOD(_this, index, value) native;\n',
         TYPE=element_type, METHOD=method_name)
-    self._js_code.Emit(
-        '\n'
-        'function native_$(CLASS)_$(METHOD)(_this, index, value) {\n'
-        '  try {\n'
-        '    return _this.$dom[index] = __dom_unwrap(value);\n'
-        '  } catch (e) {\n'
-        '    throw __dom_wrap_exception(e);\n'
-        '  }\n'
-        '}\n',
-        CLASS=self._class_name, METHOD=method_name)
 
   def AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
     body = self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS) {\n'
         '$!BODY'
         '  }\n',
         TYPE=info.type_name,
         NAME=info.name,
         PARAMS=info.ParametersImplementationDeclaration())
 
     # Process in order of ascending number of arguments to ensure missing
     # optional arguments are processed early.
     overloads = sorted(info.overloads,
                        key=lambda overload: len(overload.arguments))
     self._native_version = 0
     fallthrough = self.GenerateDispatch(body, info, '    ', 0, overloads)
     if fallthrough:
       body.Emit('    throw "Incorrect number or type of arguments";\n');
-    self._externs.add((self._interface.id, info.js_name, 'operation'))
 
   def GenerateSingleOperation(self,  emitter, info, indent, operation):
     """Generates a call to a single operation.
 
     Arguments:
       emitter: an Emitter for the body of a block of code.
       info: the compound information about the operation and its overloads.
       indent: an indentation string for generated code.
       operation: the IDLOperation to call.
     """
@@ skipping 28 matching lines @@
                    '$(INDENT)return;\n',
                    INDENT=indent,
                    NATIVENAME=native_name,
                    ARGS=argument_expressions)
 
     self._members_emitter.Emit('  static $TYPE $NAME($PARAMS) native;\n',
                                NAME=native_name,
                                TYPE=info.type_name,
                                PARAMS=', '.join(['receiver'] + arg_names) )
 
-    if (self._interface.id, info.name) not in _custom_methods:
-      alternates = _alternate_methods.get( (self._interface.id, info.name) )
-      if alternates:
-        (js_name_1, js_name_2) = alternates
-        self._js_code.Emit(
-            '\n'
-            'function native_$(CLASS)_$(NATIVENAME)($PARAMS) {\n'
-            '  try {\n'
-            '    var _method = _this.$dom.$JSNAME1 || _this.$dom.$JSNAME2;\n'
-            '    return __dom_wrap(_method.call($ARGS));\n'
-            '  } catch (e) {\n'
-            '    throw __dom_wrap_exception(e);\n'
-            '  }\n'
-            '}\n',
-            CLASS=self._class_name,
-            NAME=info.name,
-            JSNAME1=js_name_1,
-            JSNAME2=js_name_2,
-            NATIVENAME=native_name,
-            PARAMS=', '.join(['_this'] + arg_names),
-            ARGS=', '.join(['_this.$dom'] + unwrap_args))
-      else:
-        if info.js_name in _javascript_keywords:
-          access = "['%s']" % info.js_name
-        else:
-          access = ".%s" % info.js_name
-        self._js_code.Emit(
-            '\n'
-            'function native_$(CLASS)_$(NATIVENAME)($PARAMS) {\n'
-            '  try {\n'
-            '    return __dom_wrap(_this.$dom$ACCESS($ARGS));\n'
-            '  } catch (e) {\n'
-            '    throw __dom_wrap_exception(e);\n'
-            '  }\n'
-            '}\n',
-            CLASS=self._class_name,
-            NAME=info.name,
-            ACCESS=access,
-            NATIVENAME=native_name,
-            PARAMS=', '.join(['_this'] + arg_names),
-            ARGS=', '.join(unwrap_args))
-
 
   def GenerateDispatch(self, emitter, info, indent, position, overloads):
     """Generates a dispatch to one of the overloads.
 
     Arguments:
       emitter: an Emitter for the body of a block of code.
       info: the compound information about the operation and its overloads.
       indent: an indentation string for generated code.
       position: the index of the parameter to dispatch on.
       overloads: a list of the remaining IDLOperations to dispatch.
@@ skipping 539 matching lines @@
                    INDENT=indent,
                    NATIVENAME=native_name,
                    ARGS=argument_expressions)
 
     self._members_emitter.Emit('  $TYPE $NATIVE_NAME($PARAMS) native '
                                '"$(INTERFACE)$(NATIVE_NAME)_Callback";\n',
                                NATIVE_NAME=native_name,
                                TYPE=info.type_name,
                                PARAMS=', '.join(arg_names),
                                INTERFACE=self._interface.id)