IDL: Support optional argument default value syntax

Source/bindings/scripts/idl_definitions.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 457 matching lines @@
 # Arguments
 ################################################################################
 
 class IdlArgument(TypedObject):
     def __init__(self, node):
         self.extended_attributes = {}
         self.idl_type = None
         self.is_optional = node.GetProperty('OPTIONAL')  # syntax: (optional T)
         self.is_variadic = False  # syntax: (T...)
         self.name = node.GetName()
+        self.default_value = None
 
         children = node.GetChildren()
         for child in children:
             child_class = child.GetClass()
             if child_class == 'Type':
                 self.idl_type = type_node_to_type(child)
             elif child_class == 'ExtAttributes':
                 self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
             elif child_class == 'Argument':
                 child_name = child.GetName()
                 if child_name != '...':
                     raise ValueError('Unrecognized Argument node; expected "...", got "%s"' % child_name)
                 self.is_variadic = child.GetProperty('ELLIPSIS') or False
+            elif child_class == 'Default':
+                self.default_value = IdlDefaultValue(child)
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
 
 def arguments_node_to_arguments(node):
     # [Constructor] and [CustomConstructor] without arguments (the bare form)
     # have None instead of an arguments node, but have the same meaning as using
     # an empty argument list, [Constructor()], so special-case this.
     # http://www.w3.org/TR/WebIDL/#Constructor
     if node is None:
         return []
     return [IdlArgument(argument_node)
             for argument_node in node.GetChildren()]
 
 
+class IdlDefaultValue(TypedObject):

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

You don't need TypedObject here I don't think:
TypedObject is only for resolving typedefs,
and typedefs aren't applicable to *literals*.

E.g., even if you had
foo(TypeDef x = "bar")
here you're only using "bar" (and the TYPE property in the AST),
not the type of the argument.

Also this can more generically be called IdlLiteral, so I'd write this:
class IdlLiteral(object):
    ...
(In principle this could be used for constants as well,
but those are in practice very simple, so no need.)

Also could you update the class diagram in the module docstring at top?

+    def __init__(self, node):
+        self.value_type = node.GetProperty('TYPE')

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

Naming: idl_type, rather than value_type.
(might need a bit of converting)

+        if self.value_type == 'DOMString':

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

Could you factor out this evaluation into a function?

if idl_type == 'DOMString':
    return node.GetProperty('NAME')
if ...:
    ...
raise ...
...has simpler flow

+            self.value = node.GetProperty('NAME')
+        elif self.value_type == 'integer':
+            self.value = eval(node.GetProperty('NAME'))

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

!!!
Could you please use constructors int() and float()?
...as eval() causes conniptions and hives.

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

Using eval() here is clearly ridiculous. Sorry about that.

I think I meant to handle integer and float using the same expression  in which
case eval() at least added something (but then realized one used NAME and the
other VALUE, and didn't.)

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

n/p, that makes sense -- I was wondering what exactly you were on,
and this explains it!

+        elif self.value_type == 'float':
+            self.value = eval(node.GetProperty('VALUE'))

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

Could you add a FIXME for the irregular upstream treatment of NAME/VALUE?

+        elif self.value_type == 'boolean':
+            self.value = node.GetProperty('VALUE')
+        elif self.value_type == 'NULL':

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

Handling null and undefined will be a bit ugly.
We'd handle this by having properties is_null and is_undefined
(like IdlType.is_nullable).

Cleanest would be to have IdlLiteralNull and IdlLiteralUndefined
which inherit from IdlLiteral
and just override the value for is_null and is_undefined,
respectively.

In that case you'd also need to use a factory function:
default_node_to_idl_literal
...instead of calling the IdlLiteral constructor directly.

+            self.value = None
+        else:
+            raise ValueError('Unrecognized default value type: %s' % self.value_type)
+
+
 ################################################################################
 # Extended attributes
 ################################################################################
 
 def ext_attributes_node_to_extended_attributes(node):
     """
     Returns:
       Dictionary of {ExtAttributeName: ExtAttributeValue}.
       Value is usually a string, with three exceptions:
       Constructors: value is a list of Arguments nodes, corresponding to
@@ skipping 173 matching lines @@
     child_class = child.GetClass()
     if child_class != 'Type':
         raise ValueError('Unrecognized node class: %s' % child_class)
     return type_node_to_type(child)
 
 
 def union_type_node_to_idl_union_type(node, is_nullable=False):
     member_types = [type_node_to_type(member_type_node)
                     for member_type_node in node.GetChildren()]
     return IdlUnionType(member_types, is_nullable=is_nullable)