IDL (Python): allow optional values to be undefined in overload resolution

Source/bindings/scripts/unstable/v8_interface.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 355 matching lines @@
 def overload_check_expression(method, argument_count):
     overload_checks = ['info.Length() == %s' % argument_count]
     arguments = method['arguments'][:argument_count]
     overload_checks.extend(overload_check_argument(index, argument)
                            for index, argument in
                            enumerate(arguments))
     return ' && '.join('(%s)' % check for check in overload_checks if check)
 
 
 def overload_check_argument(index, argument):
+    def null_or_optional_check():
+        # If undefined is passed for an optional argument, the argument should
+        # be treated as missing; otherwise undefined is not allowed.
+        if argument['is_nullable']:
+            if argument['is_optional']:
+                return 'isUndefinedOrNull(%s)'
+            return '%s->IsNull()'
+        if argument['is_optional']:
+            return '%s->IsUndefined()'
+        return None
+
     cpp_value = 'info[%s]' % index
     idl_type = argument['idl_type']
     # FIXME: proper type checking, sharing code with attributes and methods
     if idl_type == 'DOMString' and argument['is_strict_type_checking']:
         return ' || '.join(['isUndefinedOrNull(%s)' % cpp_value,
                             '%s->IsString()' % cpp_value,
                             '%s->IsObject()' % cpp_value])
     if v8_types.array_or_sequence_type(idl_type):
         return '%s->IsArray()' % cpp_value
     if v8_types.is_callback_interface(idl_type):
         return ' || '.join(['%s->IsNull()' % cpp_value,
                             '%s->IsFunction()' % cpp_value])
     if v8_types.is_wrapper_type(idl_type):
         type_check = 'V8{idl_type}::hasInstance({cpp_value}, info.GetIsolate())'.format(idl_type=idl_type, cpp_value=cpp_value)
         if argument['is_nullable']:
             type_check = ' || '.join(['%s->IsNull()' % cpp_value, type_check])
         return type_check
     if is_interface_type(idl_type):
         # Non-wrapper types are just objects: we don't distinguish type
+        # We only allow undefined for non-wrapper types (notably Dictionary),
+        # as we need it for optional Dictionary arguments, but we don't want to
+        # change behavior of existing bindings for other types.
         type_check = '%s->IsObject()' % cpp_value
-        if argument['is_nullable']:
-            type_check = ' || '.join(['%s->IsNull()' % cpp_value, type_check])
+        added_check_template = null_or_optional_check()
+        if added_check_template:
+            type_check = ' || '.join([added_check_template % cpp_value,
+                                      type_check])
         return type_check
     return None
 
 
 ################################################################################
 # Constructors
 ################################################################################
 
 # [Constructor]
 def generate_constructor(interface, constructor):
@@ skipping 260 matching lines @@
         deleter = next(
             method
             for method in interface.operations
             if ('deleter' in method.specials and
                 len(method.arguments) == 1 and
                 method.arguments[0].idl_type == 'DOMString'))
     except StopIteration:
         return None
 
     return property_deleter(deleter)