Move splitting operations with optional arguments to generator.

lib/dom/scripts/systemnative.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 systems to generate
 native binding from the IDL database."""
 
 import emitter
 import os
@@ skipping 759 matching lines @@
           dart_declaration, 'Callback', True)
       return
 
     body = self._members_emitter.Emit(
         '\n'
         '  $DECLARATION {\n'
         '$!BODY'
         '  }\n',
         DECLARATION=dart_declaration)
 
+    if self._interface.id == 'IDBObjectStore' and info.name == 'openCursor':
+      # FIXME: implement v8-like overload resolver and remove this hack.
+      info.overloads = info.overloads[1:]
+
     self._native_version = 0
     overloads = self.CombineOverloads(info.overloads)
     fallthrough = self.GenerateDispatch(body, info, '    ', overloads)
     if fallthrough:
       body.Emit('    throw "Incorrect number or type of arguments";\n');
 
   def CombineOverloads(self, overloads):
     # Combine overloads that can be implemented by the same native method.  This
     # undoes the expansion of optional arguments into multiple overloads unless
     # IDL merging has made the overloads necessary.  Starting with overload with
     # no optional arguments and grow it by adding optional arguments, then the
     # longest overload can serve for all the shorter ones.
     out = []
     seed_index = 0
     while seed_index < len(overloads):
       seed = overloads[seed_index]
-      if len(seed.arguments) > 0 and seed.arguments[-1].is_optional:
+      if len(seed.arguments) > 0 and IsOptional(seed.arguments[-1]):
         # Must start with no optional arguments.
         out.append(seed)
         seed_index += 1
         continue
 
       prev = seed
       probe_index = seed_index + 1
       while probe_index < len(overloads):
         probe = overloads[probe_index]
         # Check that 'probe' extends 'prev' by one optional argument.
         if len(probe.arguments) != len(prev.arguments) + 1:
           break
         if probe.arguments[:-1] != prev.arguments:
           break
-        if not probe.arguments[-1].is_optional:
+        if not IsOptional(probe.arguments[-1]):
           break
         # See Issue 3177.  This test against known implemented types is to
         # prevent combining a possibly unimplemented type.  Combining with an
         # unimplemented type will cause all set of combined overloads to become
         # 'unimplemented', even if no argument is passed to the the
         # unimplemented parameter.
         if DartType(probe.arguments[-1].type.id) not in [
             'String', 'int', 'num', 'double', 'bool',
             'IDBKeyRange']:
           break
         probe_index += 1
         prev = probe
       out.append(prev)
       seed_index = probe_index
 
     return out
 
   def PrintOverloadsComment(self, emitter, info, indent, note, overloads):
     emitter.Emit('$(INDENT)//$NOTE\n', INDENT=indent, NOTE=note)
     for operation in overloads:
       params = ', '.join([
-          ('[Optional] ' if arg.is_optional else '') + DartType(arg.type.id) + ' '
+          ('[Optional] ' if IsOptional(arg) else '') + DartType(arg.type.id) + ' '
           + arg.id for arg in operation.arguments])
       emitter.Emit('$(INDENT)// $NAME($PARAMS)\n',
                    INDENT=indent,
                    NAME=info.name,
                    PARAMS=params)
     emitter.Emit('$(INDENT)//\n', INDENT=indent)
 
   def GenerateDispatch(self, emitter, info, indent, overloads):
     """Generates a dispatch to one of the overloads.
 
@@ skipping 73 matching lines @@
           dart_type = self._DartType(arg.type.id)
           if dart_type == param.dart_type:
             # The overload type matches the method parameter type exactly.  We
             # will have already tested this type in checked mode, and the target
             # will expect (i.e. check) this type.  This case happens when all
             # the overloads have the same type in this position, including the
             # trivial case of one overload.
             test = None
           else:
             test = TypeCheck(param.name, dart_type)
-            if IsNullable(dart_type) or arg.is_optional:
+            if IsNullable(dart_type) or IsOptional(arg):
               test = '(%s || %s)' % (NullCheck(param.name), test)
         else:
           test = NullCheck(param.name)
         if test:
           tests.append(test)
       if tests:
         cond = ' && '.join(tests)
         if len(cond) + len(indent) + 7 > 80:
           cond = (' &&\n' + indent + '    ').join(tests)
         call = emitter.Emit(
@@ skipping 254 matching lines @@
   for parent in interface.parents:
     parent_name = parent.type.id
     if not database.HasInterface(parent.type.id):
       continue
     parent_interface = database.GetInterface(parent.type.id)
     if callback(parent_interface):
       return parent_interface
     parent_interface = _FindParent(parent_interface, database, callback)
     if parent_interface:
       return parent_interface