Add support for native bindings generation to dartgenerator.py.

client/dom/scripts/dartgenerator.py

 #!/usr/bin/python
 # Copyright (c) 2011, 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 383 matching lines @@
         interface.parents = filter(HasAnnotations, interface.parents)
       else:
         database.DeleteInterface(interface.id)
 
     self.FilterMembersWithUnidentifiedTypes(database)
 
 
   def Generate(self, database, output_dir,
                module_source_preference=[], source_filter=None,
                super_database=None, common_prefix=None, super_map={},
-               lib_dir = None):
+               lib_dir=None, native=False):
     """Generates Dart and JS files for the loaded interfaces.
 
     Args:
       database -- database containing interfaces to generate code for.
       output_dir -- directory to write generated files to.
       module_source_preference -- priority order list of source annotations to
         use when choosing a module name, if none specified uses the module name
         from the database.
       source_filter -- if specified, only outputs interfaces that have one of
         these source annotation and rewrites the names of superclasses not
         marked with this source to use the common prefix.
       super_database -- database containing super interfaces that the generated
         interfaces should extend.
       common_prefix -- prefix for the common library, if any.
       lib_file_path -- filename for generated .lib file, None if not required.
       lib_template -- template file in this directory for generated lib file.
     """
 
     self._emitters = multiemitter.MultiEmitter()
     self._database = database
     self._output_dir = output_dir
 
     self._ComputeInheritanceClosure()
 
+    self._systems = []
+
     interface_system = InterfacesSystem(
         TemplateLoader(self._template_dir, ['dom/interface', 'dom', '']),
         self._database, self._emitters, self._output_dir)
+    self._systems.append(interface_system)
 
-    wrapping_system = WrappingImplementationSystem(
-        TemplateLoader(self._template_dir, ['dom/wrapping', 'dom', '']),
-        self._database, self._emitters, self._output_dir)
+    if native:
+        native_system = NativeImplementationSystem(
+            TemplateLoader(self._template_dir, ['dom/native', 'dom', '']),
+            self._database, self._emitters, self._auxiliary_dir,
+            self._output_dir)
+        self._systems.append(native_system)
+    else:

[sra1, 2012/01/26 05:35:30]

Is it possible to generate everything at once?

[podivilov, 2012/01/26 08:28:51]

Yes, but it would be a little bit slower, will produce lots of unused output in
Dartium, and put unversioned files under client/dom. Why do you think we should
generate everything at once? Should native files live under svn in that case?

[sra1, 2012/01/26 18:32:16]

I want to make sure that all targets *can* be generated at once, and then select
which subset from the command line.
When we get an IDL change we will be able to see the whole effect, then fix the
targets independently.
We will be generating dart:dom and dart:html and the dartium bindings.  It will
be easy to miss one.

[podivilov, 2012/01/30 19:23:50]

Added --systems switch. It defaults to 'frog,wrapping' and allows to generate
everything at once.

+      wrapping_system = WrappingImplementationSystem(
+          TemplateLoader(self._template_dir, ['dom/wrapping', 'dom', '']),
+          self._database, self._emitters, self._output_dir)
 
-    # Makes interface files available for listing in the library for the
-    # wrapping implementation.
+      # Makes interface files available for listing in the library for the
+      # wrapping implementation.
 
-    wrapping_system._interface_system = interface_system
+      wrapping_system._interface_system = interface_system
+      self._systems.append(wrapping_system)
 
-    frog_system = FrogSystem(
-        TemplateLoader(self._template_dir, ['dom/frog', 'dom', '']),
-        self._database, self._emitters, self._output_dir)
+      frog_system = FrogSystem(
+          TemplateLoader(self._template_dir, ['dom/frog', 'dom', '']),
+          self._database, self._emitters, self._output_dir)
 
-    frog_system._interface_system = interface_system
+      frog_system._interface_system = interface_system
+      self._systems.append(frog_system)
 
-    self._systems = [interface_system,
-                     wrapping_system,
-                     frog_system]
 
     # Render all interfaces into Dart and save them in files.
     for interface in database.GetInterfaces():
 
       super_interface = None
       super_name = interface.id
 
       if not _MatchSourceFilter(source_filter, interface):
         # Skip this interface since it's not present in the required source
         _logger.info('Omitting interface - %s' % interface.id)
@@ skipping 862 matching lines @@
 
 
   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 = 'DOMWrapperBase'
-    if interface.parents:
-      supertype = interface.parents[0].type.id
-      # FIXME: We're currently injecting List<..> and EventTarget as
-      # supertypes in dart.idl. We should annotate/preserve as
-      # attributes instead.  For now, this hack lets the interfaces
-      # inherit, but not the classes.
-      if (not _IsDartListType(supertype) and
-          not supertype == 'EventTarget'):
-        base = self._ImplClassName(supertype)
-      if _IsDartCollectionType(supertype):
-        # List methods are injected in AddIndexer.
-        pass
-      elif supertype == 'EventTarget':
-        # Most implementors of EventTarget specify the EventListener operations
-        # again.  If the operations are not specified, try to inherit from the
-        # EventTarget implementation.
-        #
-        # Applies to MessagePort.
-        if not [op for op in interface.operations if op.id == 'addEventListener']:
-          base = self._ImplClassName(supertype)
-      else:
-        base = self._ImplClassName(supertype)
+    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'
         '    return new $CLASS();\n'
         '  }\n'
         '$!MEMBERS'
         '\n'
         '  String get typeName() { return "$INTERFACE"; }\n'
         '}\n'
         '$!TOP_LEVEL',
         CLASS=self._class_name, BASE=base, INTERFACE=interface_name)
 
   def _ImplClassName(self, type_name):
     return '_' + type_name + 'WrappingImplementation'
 
+  def _BaseClassName(self, interface):

[antonm, 2012/01/26 11:06:14]

it looks like you can simplify this function w/ early returns: you never reuse
base var:

if not interface.parents:
  return 'DOMWrapperBase'

etc.

[podivilov, 2012/01/26 14:18:57]

Done.

+    base = 'DOMWrapperBase'
+
+    if not interface.parents:
+      return base
+
+    supertype = interface.parents[0].type.id
+    # FIXME: We're currently injecting List<..> and EventTarget as
+    # supertypes in dart.idl. We should annotate/preserve as
+    # attributes instead.  For now, this hack lets the interfaces
+    # inherit, but not the classes.
+    if (not _IsDartListType(supertype) and
+        not supertype == 'EventTarget'):
+      base = self._ImplClassName(supertype)
+    if _IsDartCollectionType(supertype):
+      # List methods are injected in AddIndexer.
+      pass
+    elif supertype == 'EventTarget':
+      # Most implementors of EventTarget specify the EventListener operations
+      # again.  If the operations are not specified, try to inherit from the
+      # EventTarget implementation.
+      #
+      # Applies to MessagePort.
+      if not [op for op in interface.operations if op.id == 'addEventListener']:
+        base = self._ImplClassName(supertype)
+    else:
+      base = self._ImplClassName(supertype)
+
+    return base
+
   def FinishInterface(self):
     """."""
     pass
 
   def AddConstant(self, constant):
     # Constants are already defined on the interface.
     pass
 
   def _MethodName(self, prefix, name):
     method_name = prefix + name
@@ skipping 73 matching lines @@
     #   interface Y extends X, List<T> ...
     #
     # In the non-root case we have to choose between:
     #
     #   class YImpl extends XImpl { add List<T> methods; }
     #
     # and
     #
     #   class YImpl extends ListBase<T> { copies of transitive XImpl methods; }
     #
-    if ('HasIndexGetter' in self._interface.ext_attrs or
-        'HasNumericIndexGetter' in self._interface.ext_attrs):
-      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)
+    if (self._HasNativeIndexGetter(self._interface)):

[antonm, 2012/01/26 11:06:14]

nit: no need in extra ()

[podivilov, 2012/01/26 14:18:57]

Done.

+      self._EmitNativeIndexGetter(self._interface, element_type)
     else:
       self._members_emitter.Emit(
           '\n'
           '  $TYPE operator[](int index) {\n'
           '    return item(index);\n'
           '  }\n',
           TYPE=element_type)
 
 
     if 'HasCustomIndexSetter' in self._interface.ext_attrs:

[antonm, 2012/01/26 11:06:14]

for symmetry, shouldn't you add _HasNativeIndexSetter method?  or inline
_HasNativeIndexGetter?

[podivilov, 2012/01/26 14:18:57]

Done.

-      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)
+      self._EmitNativeIndexSetter(self._interface, element_type)
     else:
       self._members_emitter.Emit(
           '\n'
           '  void operator[]=(int index, $TYPE value) {\n'
           '    throw new UnsupportedOperationException("Cannot assign element of immutable List.");\n'
           '  }\n',
           TYPE=element_type)
 
     self._members_emitter.Emit(
         '\n'
@@ skipping 77 matching lines @@
         '\n'
         '  bool isEmpty() {\n'
         '    return length == 0;\n'
         '  }\n'
         '\n'
         '  Iterator<$TYPE> iterator() {\n'
         '    return new _FixedSizeListIterator<$TYPE>(this);\n'
         '  }\n',
         TYPE=element_type)
 
+  def _HasNativeIndexGetter(self, interface):
+    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'

[antonm, 2012/01/26 11:06:14]

looks like if you keep a blank line before $MEMBERS in template, this, imho,
ugly leading '\n' may go away.  But if it's a common pattern here, so it be.

[podivilov, 2012/01/26 14:18:57]

You could not rely on ordering here, native index getter may easily appear after
something else.

+        '  $TYPE operator[](int index) { return $METHOD(this, index); }\n'

[antonm, 2012/01/26 11:06:14]

$TYPE operator[](int index) => $METHOD(this, index) ?

Maybe later, up to you.

[podivilov, 2012/01/26 14:18:57]

This change should produce zero diff in wrapping dom generated files.

+        '  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 _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',
@@ skipping 434 matching lines @@
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     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)))
+
+
+# ------------------------------------------------------------------------------
+
+class NativeImplementationSystem(System):
+
+  def __init__(self, templates, database, emitters, auxiliary_dir, output_dir):
+    super(NativeImplementationSystem, self).__init__(
+        templates, database, emitters, output_dir)
+
+    self._auxiliary_dir = auxiliary_dir
+
+    self._dom_public_imports_emitter = emitter.Emitter()
+    self._dom_impl_imports_emitter = emitter.Emitter()
+
+  def InterfaceGenerator(self,
+                         interface,
+                         common_prefix,
+                         super_interface_name,
+                         source_filter):
+    interface_name = interface.id
+
+    self._dom_public_imports_emitter.Emit('#source("$PATH");\n',
+        PATH=self._FilePathForDartInterface(interface_name))
+    self._dom_impl_imports_emitter.Emit('#source("$PATH");\n',
+        PATH=self._FilePathForDartImpl(interface_name))
+
+    dart_impl_path = os.path.join(self._output_dir,
+                                  self._FilePathForDartImpl(interface_name))

[antonm, 2012/01/26 11:06:14]

do you want to invoke this _FilePathForDartImpl twice?  I am not trying to speed
things up, just to have one invocation.  Minor though.

+    dart_impl_emitter = self._emitters.FileEmitter(dart_impl_path)
+
+    return NativeImplementationGenerator(interface, super_interface_name,
+                                         dart_impl_emitter,
+                                         self._BaseDefines(interface),
+                                         self._templates)
+
+  def ProcessCallback(self, interface, info):
+    self._dom_public_imports_emitter.Emit('#source("$PATH");\n',
+        PATH=self._FilePathForDartInterface(interface.id))
+
+  def GenerateLibraries(self, lib_dir):
+    auxiliary_dir = os.path.relpath(self._auxiliary_dir, self._output_dir)
+
+    # Generate dom_public.dart
+    dom_public_path = os.path.join(self._output_dir, 'dom_public.dart')
+    dom_public_emitter = self._emitters.FileEmitter(dom_public_path)
+    dom_public_emitter.Emit(self._templates.Load('dom_public.darttemplate'),
+        AUXILIARY_DIR=auxiliary_dir,
+        SOURCES=self._dom_public_imports_emitter.Fragments())
+
+    # Generate dom_impl.dart
+    dom_impl_path = os.path.join(self._output_dir, 'dom_impl.dart')
+    dom_impl_emitter = self._emitters.FileEmitter(dom_impl_path)
+    dom_impl_emitter.Emit(self._templates.Load('dom_impl.darttemplate'),
+        AUXILIARY_DIR=auxiliary_dir,
+        SOURCES=self._dom_impl_imports_emitter.Fragments())
+
+  def Finish(self):
+    pass
+
+  def _FilePathForDartInterface(self, interface_name):
+    return os.path.join('src', 'interface', '%s.dart' % interface_name)
+
+  def _FilePathForDartImpl(self, interface_name):
+    return os.path.join('dart', '%sImplementation.dart' % interface_name)
+
+
+class NativeImplementationGenerator(WrappingInterfaceGenerator):
+  """Generates Dart and c++ implementation for one DOM IDL interface."""

[antonm, 2012/01/26 11:06:14]

nit: C++

[podivilov, 2012/01/26 14:18:57]

Done.

+
+  def __init__(self, interface, super_interface, dart_impl_emitter,
+               base_members, templates):
+    """Generates Dart 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_impl_emitter: an Emitter for the file containing the Dart
+         implementation class.
+      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_impl_emitter = dart_impl_emitter
+    self._base_members = base_members
+    self._templates = templates
+    self._current_secondary_parent = None
+
+  def StartInterface(self):
+    self._class_name = self._ImplClassName(self._interface.id)
+    self._members_emitter = emitter.Emitter()
+
+  def _ImplClassName(self, type_name):
+    return type_name + 'Implementation'
+
+  def FinishInterface(self):
+    interface = self._interface
+    interface_name = interface.id
+
+    base = self._BaseClassName(interface)
+    self._dart_impl_emitter.Emit(
+        self._templates.Load('dart_implementation.darttemplate'),
+        CLASS=self._class_name, BASE=base, INTERFACE=interface_name,
+        MEMBERS=self._members_emitter.Fragments())
+
+  def AddGetter(self, attr):
+    self._members_emitter.Emit(
+        '\n'
+        '  $TYPE get $NAME() native "$(INTERFACE)_$(NAME)_Getter";\n',
+        NAME=attr.id, TYPE=attr.type.id, INTERFACE=self._interface.id)
+
+  def AddSetter(self, attr):
+    self._members_emitter.Emit(
+        '\n'
+        '  void set $NAME($TYPE) native "$(INTERFACE)_$(NAME)_Setter";\n',
+        NAME=attr.id, TYPE=attr.type.id, INTERFACE=self._interface.id)
+
+  def _HasNativeIndexGetter(self, interface):

[antonm, 2012/01/26 11:06:14]

do you need this override?

[podivilov, 2012/01/26 14:18:57]

Yes, it repeats the logic in CodeGeneratorDart.pm.

+    return ('HasCustomIndexGetter' in interface.ext_attrs or
+            'HasNumericIndexGetter' in interface.ext_attrs)
+
+  def _EmitNativeIndexGetter(self, interface, element_type):
+    native_binding = '%s_numericIndexGetter_Callback' % interface.id
+    self._members_emitter.Emit(
+        '\n'
+        '  $TYPE operator[](int index) native "$NATIVE_BINDING";\n',
+        TYPE=element_type, NATIVE_BINDING=native_binding)
+
+  def _EmitNativeIndexSetter(self, interface, element_type):
+    native_binding = '%s_numericIndexSetter_Callback' % self._interface.id
+    self._members_emitter.Emit(
+        '\n'
+        '  void operator[]=(int index, $TYPE value) native "$NATIVE_BINDING";\n',
+        TYPE=element_type, NATIVE_BINDING=native_binding)
+
+  def AddOperation(self, info):
+    """
+    Arguments:
+      info: An OperationInfo object.
+    """
+
+    if 'Custom' in info.overloads[0].ext_attrs:
+        self._members_emitter.Emit(
+            '\n'
+            '  $TYPE $NAME($PARAMETERS) native "$(INTERFACE)_$(NAME)_Callback";\n',
+            TYPE=info.type_name,
+            NAME=info.name,
+            PARAMETERS=info.ParametersImplementationDeclaration(),
+            INTERFACE=self._interface.id)
+        return
+
+    body = self._members_emitter.Emit(
+        '\n'
+        '  $TYPE $NAME($PARAMETERS) {\n'
+        '$!BODY'
+        '  }\n',
+        TYPE=info.type_name,
+        NAME=info.name,
+        PARAMETERS=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');
+
+  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.
+    """
+
+    arg_names = [info.arg_infos[i][0]
+                 for (i, arg) in enumerate(operation.arguments)]
+
+    self._native_version += 1
+    native_name = '_%s' % info.name
+    if self._native_version > 1:
+      native_name = '%s_%s' % (native_name, self._native_version)
+
+    argument_expressions = ', '.join(arg_names)
+    if info.type_name != 'void':

[antonm, 2012/01/26 11:06:14]

do you need this if?  Maybe introduce prefix which is 'return ' if type_name !=
'void' and empty string otherwise?

[podivilov, 2012/01/26 14:18:57]

Note that else clause has additional return statement. I believe code is more
readable with this if.

+      emitter.Emit('$(INDENT)return $NATIVENAME($ARGS);\n',
+                   INDENT=indent,
+                   NATIVENAME=native_name,
+                   ARGS=argument_expressions)
+    else:
+      emitter.Emit('$(INDENT)$NATIVENAME($ARGS);\n'
+                   '$(INDENT)return;\n',
+                   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)