IDL: Support 'stringifier' keyword

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 30 matching lines @@
 a generic call, via the resolve_typedefs() method.
 
 Class hierarchy (mostly containment, '<' for inheritance):
 
 IdlDefinitions
     IdlCallbackFunction < TypedObject
     IdlEnum :: FIXME: remove, just use a dict for enums
     IdlInterface
         IdlAttribute < TypedObject
         IdlConstant < TypedObject
+        IdlLiteral
         IdlOperation < TypedObject
             IdlArgument < TypedObject
+        IdlStringifier
     IdlException < IdlInterface
         (same contents as IdlInterface)
 
 TypedObject :: mixin for typedef resolution
 
 Design doc: http://www.chromium.org/developers/design-documents/idl-compiler
 """
 
 import abc
 
@@ skipping 191 matching lines @@
 
 class IdlInterface(object):
     def __init__(self, node=None):
         self.attributes = []
         self.constants = []
         self.constructors = []
         self.custom_constructors = []
         self.extended_attributes = {}
         self.operations = []
         self.parent = None
+        self.stringifier = None
         if not node:  # Early exit for IdlException.__init__
             return
 
         self.is_callback = node.GetProperty('CALLBACK') or False
         self.is_exception = False
         # FIXME: uppercase 'Partial' => 'PARTIAL' in base IDL parser
         self.is_partial = node.GetProperty('Partial') or False
         self.name = node.GetName()
 
         children = node.GetChildren()
         for child in children:
             child_class = child.GetClass()
             if child_class == 'Attribute':
                 self.attributes.append(IdlAttribute(child))
             elif child_class == 'Const':
                 self.constants.append(IdlConstant(child))
             elif child_class == 'ExtAttributes':
                 extended_attributes = ext_attributes_node_to_extended_attributes(child)
                 self.constructors, self.custom_constructors = (
                     extended_attributes_to_constructors(extended_attributes))
                 clear_constructor_attributes(extended_attributes)
                 self.extended_attributes = extended_attributes
             elif child_class == 'Operation':
                 self.operations.append(IdlOperation(child))
             elif child_class == 'Inherit':
                 self.parent = child.GetName()
+            elif child_class == 'Stringifier':
+                self.stringifier = IdlStringifier(child)
+                self.process_stringifier()
             else:
                 raise ValueError('Unrecognized node class: %s' % child_class)
 
     def resolve_typedefs(self, typedefs):
         for attribute in self.attributes:
             attribute.resolve_typedefs(typedefs)
         for constant in self.constants:
             constant.resolve_typedefs(typedefs)
         for constructor in self.constructors:
             constructor.resolve_typedefs(typedefs)
         for custom_constructor in self.custom_constructors:
             custom_constructor.resolve_typedefs(typedefs)
         for operation in self.operations:
             operation.resolve_typedefs(typedefs)
 
+    def process_stringifier(self):
+        """Add the stringifier's synthesized 'toString' operation.
+
+        Also add the stringifier's attribute or named operation child, if it has
+        one, as a regular attribute/operation of this interface."""
+        if self.stringifier.attribute:
+            self.attributes.append(self.stringifier.attribute)
+        elif self.stringifier.operation and self.stringifier.operation.name:
+            self.operations.append(self.stringifier.operation)
+        self.operations.append(self.stringifier.synthesized_operation())
+
     def merge(self, other):
         """Merge in another interface's members (e.g., partial interface)"""
         self.attributes.extend(other.attributes)
         self.constants.extend(other.constants)
         self.operations.extend(other.operations)
 
 
 class IdlException(IdlInterface):
     # Properly exceptions and interfaces are distinct, and thus should inherit a
     # common base class (say, "IdlExceptionOrInterface").
@@ skipping 240 matching lines @@
     # 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()]
 
 
 ################################################################################
+# Stringifiers
+################################################################################
+
+class IdlStringifier(object):
+    def __init__(self, node):
+        self.attribute = None
+        self.operation = None
+        self.extended_attributes = {}
+
+        for child in node.GetChildren():
+            child_class = child.GetClass()
+            if child_class == 'Attribute':
+                self.attribute = IdlAttribute(child)
+            elif child_class == 'Operation':
+                self.operation = IdlOperation(child)
+            elif child_class == 'ExtAttributes':
+                self.extended_attributes = ext_attributes_node_to_extended_attributes(child)
+            else:
+                raise ValueError('Unrecognized node class: %s' % child_class)
+
+        # Copy the stringifier's extended attributes (such as [Unforgable]) onto
+        # the underlying attribute or operation, if there is one.
+        if self.attribute or self.operation:
+            (self.attribute or self.operation).extended_attributes.update(
+                self.extended_attributes)
+
+    def synthesized_operation(self):
+        """Return a synthesized 'toString' operation from the stringifier."""

[Jens Widell, 2014/06/23 14:08:07]

I don't know if we think this is too much logic to put here in idl_definitions.
Synthesizing an IdlOperation like this was a convenient way to implement it.

[haraken, 2014/06/23 16:33:18]

Yeah, this looks like a bit too much logic in idl_defitions. We might want to
avoid writing "toString" or "ImplementedAs" here.

[Jens Widell, 2014/06/24 08:00:29]

Moved this code into interface_context() in v8_interface.py now. As a result,
the synthesized toString() method ends up last rather than where the stringifier
was declared in the interface, so there is now some superficial CG changes.

+        operation = IdlOperation()
+        operation.name = 'toString'
+        operation.idl_type = IdlType('DOMString')
+        operation.extended_attributes.update(self.extended_attributes)
+        if self.attribute:
+            operation.extended_attributes['ImplementedAs'] = self.attribute.name
+        elif self.operation and self.operation.name:
+            operation.extended_attributes['ImplementedAs'] = self.operation.name
+        return operation
+
+
+################################################################################
 # 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
         possible signatures of the constructor.
@@ skipping 172 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)