IDL: Auto-declare remaining methods implied by maplike<>/setlike<>

Source/bindings/scripts/v8_interface.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 # coding=utf-8
 #
 # 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
@@ skipping 304 matching lines @@
                     for method in interface.operations
                     if method.name])  # Skip anonymous special operations (methods)
     if interface.partial_interfaces:
         assert len(interface.partial_interfaces) == len(set(interface.partial_interfaces))
         for partial_interface in interface.partial_interfaces:
             methods.extend([v8_methods.method_context(interface, operation, is_visible=False)
                             for operation in partial_interface.operations
                             if operation.name])
     compute_method_overloads_context(interface, methods)
 
-    def generated_method(return_type, name, arguments=None, extended_attributes=None):
+    def generated_method(return_type, name, arguments=None, extended_attributes=None, implemented_as=None):
         operation = IdlOperation(interface.idl_name)
         operation.idl_type = return_type
         operation.name = name
         if arguments:
             operation.arguments = arguments
         if extended_attributes:
             operation.extended_attributes.update(extended_attributes)
+        if implemented_as is None:
+            implemented_as = name + 'ForBinding'
+        operation.extended_attributes['ImplementedAs'] = implemented_as
         return v8_methods.method_context(interface, operation)
 
     def generated_argument(idl_type, name, is_optional=False, extended_attributes=None):
         argument = IdlArgument(interface.idl_name)
         argument.idl_type = idl_type
         argument.name = name
         argument.is_optional = is_optional
         if extended_attributes:
             argument.extended_attributes.update(extended_attributes)
         return argument
@@ skipping 25 matching lines @@
         used_extended_attributes.update({
             'RaisesException': None,
             'CallWith': 'ScriptState',
         })
 
         forEach_extended_attributes = used_extended_attributes.copy()
         forEach_extended_attributes.update({
             'CallWith': ['ScriptState', 'ThisValue'],
         })
 
-        def generated_iterator_method(name):
+        def generated_iterator_method(name, implemented_as=None):
             return generated_method(
                 return_type=IdlType('Iterator'),
                 name=name,
-                extended_attributes=used_extended_attributes)
+                extended_attributes=used_extended_attributes,
+                implemented_as=implemented_as)
 
-        iterator_method = generated_iterator_method('iterator')
+        iterator_method = generated_iterator_method('iterator', implemented_as='iterator')
 
         if interface.iterable or interface.maplike or interface.setlike:
             implicit_methods = [
                 generated_iterator_method('keys'),
                 generated_iterator_method('values'),
                 generated_iterator_method('entries'),
 
                 # void forEach(Function callback, [Default=Undefined] optional any thisArg)
                 generated_method(IdlType('void'), 'forEach',
                                  arguments=[generated_argument(IdlType('Function'), 'callback'),
                                             generated_argument(IdlType('any'), 'thisArg',
                                                                is_optional=True,
                                                                extended_attributes={'Default': 'Undefined'})],
                                  extended_attributes=forEach_extended_attributes),
             ]
 
+            if interface.maplike:
+                key_argument = generated_argument(interface.maplike.key_type, 'key')
+                value_argument = generated_argument(interface.maplike.value_type, 'value')
+
+                implicit_methods.extend([
+                    generated_method(IdlType('boolean'), 'has',
+                                     arguments=[key_argument],
+                                     extended_attributes=used_extended_attributes),
+                    generated_method(IdlType('any'), 'get',
+                                     arguments=[key_argument],
+                                     extended_attributes=used_extended_attributes),
+                ])
+
+                if not interface.maplike.is_read_only:
+                    implicit_methods.extend([
+                        generated_method(IdlType('void'), 'clear',
+                                         extended_attributes=used_extended_attributes),
+                        generated_method(IdlType('boolean'), 'delete',
+                                         arguments=[key_argument],
+                                         extended_attributes=used_extended_attributes),
+                        generated_method(IdlType(interface.name), 'set',
+                                         arguments=[key_argument, value_argument],
+                                         extended_attributes=used_extended_attributes),
+                    ])
+
+            if interface.setlike:
+                value_argument = generated_argument(interface.setlike.value_type, 'value')
+
+                implicit_methods.extend([
+                    generated_method(IdlType('boolean'), 'has',
+                                     arguments=[value_argument],
+                                     extended_attributes=used_extended_attributes),
+                ])
+
+                if not interface.setlike.is_read_only:
+                    implicit_methods.extend([
+                        generated_method(IdlType(interface.name), 'add',
+                                         arguments=[value_argument],
+                                         extended_attributes=used_extended_attributes),
+                        generated_method(IdlType('void'), 'clear',
+                                         extended_attributes=used_extended_attributes),
+                        generated_method(IdlType('boolean'), 'delete',
+                                         arguments=[value_argument],
+                                         extended_attributes=used_extended_attributes),
+                    ])
+
             methods_by_name = {}
             for method in methods:
                 methods_by_name.setdefault(method['name'], []).append(method)
 
             for implicit_method in implicit_methods:
                 if implicit_method['name'] in methods_by_name:
                     # FIXME: Check that the existing method is compatible.
                     continue
                 methods.append(implicit_method)
 
         # FIXME: maplike<> and setlike<> should also imply the presence of a
-        # subset of keys(), values(), entries(), forEach(), has(), get(), add(),
-        # set(), delete() and clear(), and a 'size' attribute.
+        # 'size' attribute.
 
     # Stringifier
     if interface.stringifier:
         stringifier = interface.stringifier
         stringifier_ext_attrs = stringifier.extended_attributes.copy()
         if stringifier.attribute:
             stringifier_ext_attrs['ImplementedAs'] = stringifier.attribute.name
         elif stringifier.operation:
             stringifier_ext_attrs['ImplementedAs'] = stringifier.operation.name
         methods.append(generated_method(
             return_type=IdlType('DOMString'),
             name='toString',
-            extended_attributes=stringifier_ext_attrs))
+            extended_attributes=stringifier_ext_attrs,
+            implemented_as='toString'))
 
     conditionally_enabled_methods = []
     custom_registration_methods = []
     method_configuration_methods = []
 
     for method in methods:
         # Skip all but one method in each set of overloaded methods.
         if 'overload_index' in method and 'overloads' not in method:
             continue
 
@@ skipping 808 matching lines @@
     if str(idl_type) != 'boolean':
         raise Exception(
             'Only deleters with boolean type are allowed, but type is "%s"' %
             idl_type)
     extended_attributes = deleter.extended_attributes
     return {
         'is_custom': 'Custom' in extended_attributes,
         'is_raises_exception': 'RaisesException' in extended_attributes,
         'name': cpp_name(deleter),
     }