Set correct Function.length on overloaded methods

Source/bindings/templates/methods.cpp

 {##############################################################################}
 {% macro generate_method(method, world_suffix) %}
 {% filter conditional(method.conditional_string) %}
 static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     {# Local variables #}
     {% if method.has_exception_state %}
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "{{method.name}}", "{{interface_name}}", info.Holder(), info.GetIsolate());
     {% endif %}
     {# Overloaded methods have length checked during overload resolution #}
@@ skipping 393 matching lines @@
     {% else %}
     {{cpp_class}}V8Internal::{{method.name}}Method{{world_suffix}}(info);
     {% endif %}
     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 }
 {% endfilter %}
 {% endmacro %}
 
 
 {##############################################################################}
+{% macro method_length(method) %}
+{% if method.overloads %}
+{{method.overloads.minarg}}

[Jens Widell, 2014/06/02 08:46:43]

This is of course possibly incorrect if the "shortest" overload is runtime
enabled...

[Nils Barth (inactive), 2014/06/04 07:22:02]

Good catch!
I assume this can't be fixed without generating some really ugly code for method
configuration, right?

What I'd suggest is:
* Put a FIXME at this computation (as noted, in Python).
* Check for this and raise an exception in the CG (doubt it will happen, but
it's possible): it's better to prevent people from adding unsupported cases than
to allow them to accidentally break things.

[Jens Widell, 2014/06/04 07:38:36]

I guess we could generate a simple per-method helper function (when necessary)
for calculating the length, and then make {{method.length}} expand to a call to
it.

Seems overkill to do that until we find a case where we actually think it's
necessary. :-)
Will do.

[Nils Barth (inactive), 2014/06/04 08:12:01]

More seriously, the issue of implementing JS properties via constants vs.
functions does show up periodically in exactly this context, like in having
logging for constants, which requires having a function implementing them.

Philip is actually interested in this for deprecation, so this would be both
useful and a way to get started on understanding V8 implementation of Web IDL
interfaces:
https://code.google.com/p/chromium/issues/detail?id=358506
Agreed: implement when needed (or encourage the requester to implement it ;)

+{%- else %}
+{{method.number_of_required_or_variadic_arguments}}

[Jens Widell, 2014/05/27 12:11:21]

This value is actually wrong per spec. It counts a variadic argument as one, but
if I understand the spec correctly it should count as zero. IOW,

  void f(long... l)

should have length=0. I kept it to minimize the impact of this CL, but can fix
if we want, simply by dropping the '_or_variadic' part.

[jsbell, 2014/05/27 18:10:50]

IMHO, we might as well fix it. (If not, we should at least add a FIXME here) I
suspect it will break exactly zero tests.

+{%- endif %}
+{% endmacro %}
+
+
+{##############################################################################}
 {% macro origin_safe_method_getter(method, world_suffix) %}
 static void {{method.name}}OriginSafeMethodGetter{{world_suffix}}(const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     {% set signature = 'v8::Local<v8::Signature>()'
                        if method.is_do_not_check_signature else
                        'v8::Signature::New(isolate, %s::domTemplate(isolate))' % v8_class %}
     v8::Isolate* isolate = info.GetIsolate();
     static int domTemplateKey; // This address is used for a key to look up the dom template.
     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
     {# FIXME: 1 case of [DoNotCheckSignature] in Window.idl may differ #}
-    v8::Handle<v8::FunctionTemplate> privateTemplate = data->domTemplate(&domTemplateKey, {{cpp_class}}V8Internal::{{method.name}}MethodCallback{{world_suffix}}, v8Undefined(), {{signature}}, {{method.number_of_required_or_variadic_arguments}});
+    v8::Handle<v8::FunctionTemplate> privateTemplate = data->domTemplate(&domTemplateKey, {{cpp_class}}V8Internal::{{method.name}}MethodCallback{{world_suffix}}, v8Undefined(), {{signature}}, {{method_length(method)}});
 
     v8::Handle<v8::Object> holder = {{v8_class}}::findInstanceInPrototypeChain(info.This(), isolate);
     if (holder.IsEmpty()) {
         // This is only reachable via |object.__proto__.func|, in which case it
         // has already passed the same origin security check
         v8SetReturnValue(info, privateTemplate->GetFunction());
         return;
     }
     {{cpp_class}}* impl = {{v8_class}}::toNative(holder);
     if (!BindingSecurity::shouldAllowAccessToFrame(isolate, impl->frame(), DoNotReportSecurityError)) {
         static int sharedTemplateKey; // This address is used for a key to look up the dom template.
-        v8::Handle<v8::FunctionTemplate> sharedTemplate = data->domTemplate(&sharedTemplateKey, {{cpp_class}}V8Internal::{{method.name}}MethodCallback{{world_suffix}}, v8Undefined(), {{signature}}, {{method.number_of_required_or_variadic_arguments}});
+        v8::Handle<v8::FunctionTemplate> sharedTemplate = data->domTemplate(&sharedTemplateKey, {{cpp_class}}V8Internal::{{method.name}}MethodCallback{{world_suffix}}, v8Undefined(), {{signature}}, {{method_length(method)}});
         v8SetReturnValue(info, sharedTemplate->GetFunction());
         return;
     }
 
     {# The findInstanceInPrototypeChain() call above only returns a non-empty handle if info.This() is an Object. #}
     v8::Local<v8::Value> hiddenValue = v8::Handle<v8::Object>::Cast(info.This())->GetHiddenValue(v8AtomicString(isolate, "{{method.name}}"));
     if (!hiddenValue.IsEmpty()) {
         v8SetReturnValue(info, hiddenValue);
         return;
     }
@@ skipping 97 matching lines @@
     {% endif %}
     {{constructor.cpp_type}} impl = {{cpp_class}}::createForJSConstructor({{constructor.argument_list | join(', ')}});
     {% if is_constructor_raises_exception %}
     if (exceptionState.throwIfNeeded())
         return;
     {% endif %}
 
     {{generate_constructor_wrapper(constructor) | indent}}
 }
 {% endmacro %}