IDL: Support optional argument default value syntax

Source/bindings/scripts/v8_methods.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 150 matching lines @@
     extended_attributes = argument.extended_attributes
     idl_type = argument.idl_type
     this_cpp_value = cpp_value(interface, method, index)
     is_variadic_wrapper_type = argument.is_variadic and idl_type.is_wrapper_type
 
     return {
         'cpp_type': idl_type.cpp_type_args(extended_attributes=extended_attributes,
                                            used_as_argument=True,
                                            used_as_variadic_argument=argument.is_variadic),
         'cpp_value': this_cpp_value,
+        'default_value': default_value_to_cpp_value(argument),

[Nils Barth (inactive), 2014/06/04 05:22:24]

Using a property this is more cleanly:
argument.default_value.cpp_value if argument.default_value else None

[Jens Widell, 2014/06/04 06:12:18]

I'm using the argument's type to generate different code for null values, which
can't be done the exact same way if this is changed to read a property off of
the default value object.

Do you have a preferred approach to get around that?

[Nils Barth (inactive), 2014/06/04 06:33:35]

Ow, good point. (>.<)

2 possible approaches:
1. Make it a property on the argument:
argument.default_cpp_value
This is easier, and perhaps more correct.

2. Put the IDL type (of the argument) in the IdlLiteral
...so it's available to default_value.
This is a bit weird at the level of the parser (violates tree structure of AST
in object construction), but seems cleaner from the CG.

1 (property on the argument) seems better (simpler, more correct), though I
can't tell without actually implementing it.

WDYT?

[Jens Widell, 2014/06/04 09:49:16]

I ended up tentatively going for a third option:

3) Add operator=(nullptr_t) to V8StringResource and always emit "nullptr" for
null values.

But I also reverted all the changes to V8StringResource.h in this CL, so the
only part of it that is visible is the "always emit "nullptr"" part.

If we don't want that assignment operator, I can always implement your option 1
in the follow-up in such a way that it just checks for the "null string" case,
emits "String()" then, and otherwise uses "str(default_value)".

         'enum_validation_expression': idl_type.enum_validation_expression,
         'has_default': 'Default' in extended_attributes,
         'has_event_listener_argument': any(
             argument_so_far for argument_so_far in method.arguments[:index]
             if argument_so_far.idl_type.name == 'EventListener'),
         'has_type_checking_interface':
             (has_extended_attribute_value(interface, 'TypeChecking', 'Interface') or
              has_extended_attribute_value(method, 'TypeChecking', 'Interface')) and
             idl_type.is_wrapper_type,
         'has_type_checking_unrestricted':
@@ skipping 97 matching lines @@
 
     return '%s(%s)' % (macro, ', '.join(macro_args))
 
 
 def v8_value_to_local_cpp_value(argument, index):
     extended_attributes = argument.extended_attributes
     idl_type = argument.idl_type
     name = argument.name
     if argument.is_variadic:
         return v8_value_to_local_cpp_variadic_value(argument, index)
-    # [Default=NullString]
-    if (argument.is_optional and idl_type.name == 'String' and
-        extended_attributes.get('Default') == 'NullString'):
-        v8_value = 'argumentOrNull(info, %s)' % index

[Nils Barth (inactive), 2014/06/04 06:33:36]

You can get rid of argumentOrNull from V8Binding.h now, right?

-    else:
-        v8_value = 'info[%s]' % index
-    return idl_type.v8_value_to_local_cpp_value(extended_attributes, v8_value,
+    return idl_type.v8_value_to_local_cpp_value(extended_attributes, 'info[%s]' % index,
                                                 name, index=index, declare_variable=False)
 
 
+def default_value_to_cpp_value(argument):

[Nils Barth (inactive), 2014/06/04 05:22:24]

Could you make this a property?
(For slickness and consistency.)
...via:
IdlLiteral.cpp_value = property(idl_literal_to_cpp_value)

+    default_value = argument.default_value

[Nils Barth (inactive), 2014/06/04 05:22:24]

Might be clearer to also have:
value_type = default_value.value_type
value = default_value.value
(after the None check)
...since these are used throughout.

+    if default_value is None:

[Nils Barth (inactive), 2014/06/04 05:22:24]

if not default_value:
...per:
Use the "implicit" false if at all possible.
http://google-styleguide.googlecode.com/svn/trunk/pyguide.html?showone=True/F...

...but actually can be eliminated by moving the check for default value to the
call site.

+        return None
+    if default_value.value_type == 'DOMString':
+        if '"' in default_value.value or '\\' in default_value.value:
+            raise ValueError('Unsupported string value: %r' % default_value.value)
+        return 'String("%s")' % default_value.value
+    if default_value.value_type == 'integer':
+        return '%d' % default_value.value

[Nils Barth (inactive), 2014/06/04 05:22:24]

Could you put all this "string representation" logic in
IdlLiteral.__str__ ?

+    if default_value.value_type == 'float':
+        return '%g' % default_value.value
+    if default_value.value_type == 'boolean':
+        return 'true' if default_value.value else 'false'
+    if default_value.value_type == 'NULL':
+        if argument.idl_type.name in ('String', 'StringOrNull'):
+            return 'String()'
+        return 'nullptr'
+

[Nils Barth (inactive), 2014/06/04 05:22:24]

...do you mean to implicitly return None here?
(...or raise an exception?)

[Jens Widell, 2014/06/04 06:12:18]

Not really, no. I am handling all value types that the parser accepts, so it
currently won't happen, but to be clear, ought to raise an exception here as
well.

+
 ################################################################################
 # Auxiliary functions
 ################################################################################
 
 # [NotEnumerable]
 def property_attributes(method):
     extended_attributes = method.extended_attributes
     property_attributes_list = []
     if 'NotEnumerable' in extended_attributes:
         property_attributes_list.append('v8::DontEnum')
     if 'ReadOnly' in extended_attributes:
         property_attributes_list.append('v8::ReadOnly')
     if property_attributes_list:
         property_attributes_list.insert(0, 'v8::DontDelete')
     return property_attributes_list
 
 
 def union_arguments(idl_type):
     """Return list of ['result0Enabled', 'result0', 'result1Enabled', ...] for union types, for use in setting return value"""
     return [arg
             for i in range(len(idl_type.member_types))
             for arg in ['result%sEnabled' % i, 'result%s' % i]]
 
 IdlType.union_arguments = property(lambda self: None)
 IdlUnionType.union_arguments = property(union_arguments)