Support optional callbacks.

client/dom/scripts/systemwrapping.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
 wrapping binding from the IDL database."""
 
 import os
 from generator import *
@@ skipping 436 matching lines @@
       if len(overloads) > 1:
         raise Exception('Duplicate operations ' + str(overloads))
       operation = overloads[0]
       self.GenerateSingleOperation(emitter, info, indent, operation)
       return False
 
     # FIXME: Consider a simpler dispatch that iterates over the
     # overloads and generates an overload specific check.  Revisit
     # when we move to named optional arguments.
 
+    if position == 0:
+      # Optional callback arguments are special.  C++ counterparts do not have proper optional
+      # arguments (as in some cases C++ counterparts require ec) and thus 0 ref ptrs are passed
+      # instead of missing arguments.  That means the only allowed form is a list of
+      # arguments with trailing optional callbacks and we don't need any dispatch at all.
+      def IsOptionalCallback(arg): return arg.is_optional and 'Callback' in arg.ext_attrs
+      first_optional_callback = None
+      for (i, arg) in enumerate(overloads[-1].arguments):
+        if IsOptionalCallback(arg):
+          first_optional_callback = i
+          break
+      if first_optional_callback is not None:
+        for overload in overloads:
+          for arg in overload.arguments[first_optional_callback:]:
+            if not IsOptionalCallback(arg):
+              raise Exception('Invalid overloading with optional callbacks')
+        self.GenerateSingleOperation(emitter, info, indent, overloads[-1])
+        return False
+
     # Partition the overloads to divide and conquer on the dispatch.
     positive = []
     negative = []
     first_overload = overloads[0]
     (param_name, param_type, param_default) = info.arg_infos[position]
 
     if position < len(first_overload.arguments):
       # FIXME: This will not work if the second overload has a more
       # precise type than the first.  E.g.,
       # void foo(Node x);
@@ skipping 45 matching lines @@
     # dispatch has removed f(X), leaving only f(Y), but there is no guarantee
     # that Y = Z-X, so we need to check for Y.
     true_code = emitter.Emit(
         '$(INDENT)if ($COND) {\n'
         '$!TRUE'
         '$(INDENT)}\n',
         COND=test, INDENT=indent)
     self.GenerateDispatch(
         true_code, info, indent + '  ', position + 1, positive)
     return True