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

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);
       # void foo(Element x);
       type = DartType(first_overload.arguments[position].type.id)
       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)
 
     for overload in overloads:
       if pred(overload):
         positive.append(overload)
       else:
         negative.append(overload)
 
@@ skipping 30 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