Set correct Function.length on overloaded methods

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 239 matching lines @@
                for method in interface.operations
                if method.name]  # Skip anonymous special operations (methods)
     generate_method_overloads(methods)
     for method in methods:
         method['do_generate_method_configuration'] = (
             method['do_not_check_signature'] and
             not method['per_context_enabled_function'] and
             # For overloaded methods, only generate one accessor
             ('overload_index' not in method or method['overload_index'] == 1))
 
+        # The value of the Function object’s “length” property is a Number
+        # determined as follows:
+        # 1. Let S be the effective overload set for regular operations (if the
+        # operation is a regular operation) or for static operations (if the
+        # operation is a static operation) with identifier id on interface I and
+        # with argument count 0.
+        # 2. Return the length of the shortest argument list of the entries in S.
+        # FIXME: This calculation doesn't take into account whether runtime
+        # enabled overloads are actually enabled.

[Nils Barth (inactive), 2014/06/05 00:26:22]

Could you elaborate slightly, giving an example?
E.g.:
# FIXME: This calculation doesn't take into account whether runtime
# enabled overloads are actually enabled, so length may be too *long*.
# E.g., [RuntimeEnabled=Foo] void f(); void f(long x);
# has length 1 if Foo is not enabled, but length 0 if Foo is enabled.

+        method['length'] = method['overloads']['minarg'] if 'overloads' in method else method['number_of_required_arguments']

[Nils Barth (inactive), 2014/06/05 00:26:22]

Could you wrap this line?

+
     template_contents.update({
         'has_origin_safe_method_setter': any(
             method['is_check_security_for_frame'] and not method['is_read_only']
             for method in methods),
         'has_method_configuration': any(method['do_generate_method_configuration'] for method in methods),
         'has_per_context_enabled_methods': any(method['per_context_enabled_function'] for method in methods),
         'methods': methods,
     })
 
     template_contents.update({
@@ skipping 80 matching lines @@
     Sets |method.overload_index| in place for |method| in |overloads|
     and returns dict of overall overload template values.
     """
     assert len(overloads) > 1  # only apply to overloaded names
     for index, method in enumerate(overloads, 1):
         method['overload_index'] = index
 
     effective_overloads_by_length = effective_overload_set_by_length(overloads)
     lengths = [length for length, _ in effective_overloads_by_length]
 
+    # Check and fail if all overloads with the shortest acceptable arguments

[Nils Barth (inactive), 2014/06/05 00:26:22]

Thanks, this is a great explanation!

+    # list are runtime enabled, since we would otherwise set 'length' on the
+    # function object to an incorrect value when none of those overloads were
+    # actually enabled at runtime. The exception is if all overloads are
+    # controlled by the same runtime enabled feature, in which case there would
+    # be no function object at all if it is not enabled.
+    if (not common_value(overloads, 'runtime_enabled_function') and
+        all(method.get('runtime_enabled_function') for method, _, _ in effective_overloads_by_length[0][1])):

[Nils Barth (inactive), 2014/06/05 00:26:22]

Style points:
* Could you wrap this line?
* Could you switch the order of tests so they accord with the (clear) prose: the
"not common_value" is the exceptional case.
* The [0][1] is a bit opaque; could you add an auxiliary variable, like:
shortest_overloads = effective_overloads_by_length[0][1]
?

+        raise ValueError('Function.length of %s depends on runtime enabled features' % overloads[0]['name'])
+
     return {
         'deprecate_all_as': common_value(overloads, 'deprecate_as'),  # [DeprecateAs]
         'length_tests_methods': length_tests_methods(effective_overloads_by_length),
         'minarg': lengths[0],
         # 1. Let maxarg be the length of the longest type list of the
         # entries in S.
         'maxarg': lengths[-1],
         'measure_all_as': common_value(overloads, 'measure_as'),  # [MeasureAs]
         'valid_arities': lengths
             # Only need to report valid arities if there is a gap in the
@@ skipping 637 matching lines @@
         deleter = next(
             method
             for method in interface.operations
             if ('deleter' in method.specials and
                 len(method.arguments) == 1 and
                 str(method.arguments[0].idl_type) == 'DOMString'))
     except StopIteration:
         return None
 
     return property_deleter(deleter)