Support Dart optional arguments which are not dispatched, but instead use default values.

client/dom/scripts/systemwrapping.py

Index: client/dom/scripts/systemwrapping.py
diff --git a/client/dom/scripts/systemwrapping.py b/client/dom/scripts/systemwrapping.py
index 50073e23c5aeb1f348a28d6e1fe25c8c0a1ff206..e621dbc5cc1b521bfdb6b2a97df9f255d643a80d 100644
--- a/client/dom/scripts/systemwrapping.py
+++ b/client/dom/scripts/systemwrapping.py
@@ -454,25 +454,6 @@ class WrappingInterfaceGenerator(object):
     # 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 = []
@@ -488,6 +469,18 @@ class WrappingInterfaceGenerator(object):
       test = TypeCheck(param_name, type)
       pred = lambda op: len(op.arguments) > position and DartType(op.arguments[position].type.id) == type
     else:
+      def IsConvertNullToDefaultValue(arg): return 'DartConvertNullToDefaultValue' in arg.ext_attrs

[sra1, 2012/02/28 22:04:42]

Lines too long

[antonm, 2012/02/29 10:29:40]

Done.

+      # Check if we dispatch on ConvertNullToDefaultValue arguments.  In this case all
+      # trailing arguments must be ConvertNullToDefaultValue and there is no need in dispatch.
+      # TODO(antonm): better diagnositics.
+      last_overload = overloads[-1]
+      if len(last_overload.arguments) > position and IsConvertNullToDefaultValue(last_overload.arguments[position]):
+        for overload in overloads:
+          if not all([IsConvertNullToDefaultValue(arg) for arg in overload.arguments[position:]]):
+            raise Exception('Invalid overload with ConvertNullToDefaultValues')
+        self.GenerateSingleOperation(emitter, info, indent, last_overload)
+        return False

[podivilov, 2012/02/28 17:46:24]

Could you please move this to another block, so it doesn't mess with (type,
test, pred) logic?

[antonm, 2012/02/28 19:22:08]

Again, I'll do that, but first I'll try to object :)

This is a special case when we meet a special kind of optional.  It naturally
belongs to this else clause, but, of course, I can repeat if condition above.

Once again, Stephen, I'd be happy to learn what you think about it and as you
both have ways more experience with this code base, I'll follow your advice.

[sra1, 2012/02/28 22:04:42]

So it possible (at least theoretically) to have a dispatch AND an argument that
is DartConvertNullToDefaultValue 
E.g.
  foo(int x, [DartConvertNullToDefaultValue, Optional] y);
  foo(String s, [DartConvertNullToDefaultValue, Optional] z);

If so, the test is in the 'right' place but it is unfortunate that so much of
the machinery of the dispatch generation surrounds it.

I would move it back up,  and factor out the predicate, so it reads something
like this:

if self._SingleDispatchDueToForcedPassingOfOptionalValues(position, ..., ):
  self._GenerateSingle...
  return False

[antonm, 2012/02/29 10:29:40]

Yes, IDBDatabase.transaction is exactly the example.
Ok, what you both think about the following variant?

+
       type = None
       test = NullCheck(param_name)
       pred = lambda op: position >= len(op.arguments)